Dev.to Security πŸ” Cybersecurity πŸ‘ 0 πŸ“– 36 min read

Schannel Event 36887, 36888, and 36874 (Fatal Alert 40 or 70): A Read-First Protocol, Cipher Suite, and Peer Triage

Helpdesk: "Since last night's patching, APP02's System log has hundreds of Schannel errors: Event 36887 'A fatal alert was received from the remote endpoint. The TLS protocol defined fatal alert code is 70.' and Event 36

Helpdesk: "Since last night's patching, APP02's System log has hundreds of Schannel errors: Event 36887 'A fatal alert was received from the remote endpoint. The TLS protocol defined fatal alert code is 70.' and Event 36888 'A fatal alert was generated and sent to the remote endpoint. This may result in termination of the connection. The TLS protocol defined fatal error code is 40. The Windows SChannel error state is 1205.' The vendor's nightly upload to their API failed, and IIS01 is logging 36874s too. A forum post says to re-enable TLS 1.0 and 1.1 on every server and import a cipher suite template from a hardening tool. Can we do that?"

Not yet. Schannel Events 36887, 36888, and 36874 aren't a diagnosis. They're Windows writing down that a TLS handshake ended: 36887 means this computer received a fatal alert from the other side, 36888 means this computer generated one and sent it, and 36874 means this server got a client hello it couldn't match with any cipher suite it has enabled. The alert number says why (40 is handshake_failure, 70 is protocol_version, 10 is unexpected_message), and which side logged which event tells you where to look. Microsoft's Schannel reference words 36887 this way: "This alert message indicates this computer received a TLS or SSL fatal alert message from the server it was communicating or negotiating with. The error indicates a state in the communication process, not necessarily a problem with the application." And 36888: "This event indicates that this computer (the computer that logs this event) has detected an error condition and generated a fatal alert to notify the other party about it." Re-enabling TLS 1.0 and 1.1 everywhere doesn't read any of that. Work through it as a chain: which computer logged which event, when, and since what change? Ò†’ what is the alert number, and who sent it? Ò†’ who is the peer, and which process on this side? Ò†’ which protocol versions are enabled on each side? Ò†’ which cipher suites does each side have, and who controls the list? Ò†’ is the application, not Windows, choosing an old version? Ò†’ is it really a certificate alert? Ò†’ what do the Client Hello and Server Hello say? Ò†’ change one link Ò†’ prove it with the same peer. Get-WinEvent, Get-NetTCPConnection, Get-ChildItem and Get-ItemProperty on the SCHANNEL Protocols key, Get-TlsCipherSuite, the cipher suite policy value, the .NET and WinHTTP registry values, netsh http show sslcert, and pktmon are the sources for that chain. Turn TLS 1.0 back on everywhere and you've reopened a deprecated protocol on every server for a peer you haven't named yet, and if the alert was 40 because of a cipher mismatch, it doesn't even fix it.

If the alerts line up with WSUS failing to sync or download from Microsoft, WSUS Not Downloading Updates covers that TLS path. If the server logging them is a domain controller and the port is 636, LDAPS Not Working on a Domain Controller covers the certificate and LDAP side. This post covers "a Windows Server or Windows client logging Schannel Event 36887 (fatal alert received), 36888 (fatal alert generated), or 36874 (no common cipher suite) in the System log, with alert code 40, 70, 10, or another number, often after patching, a hardening baseline, a TLS 1.0 and 1.1 shutdown, or a new partner, appliance, or API, and you need a read-first path before you re-enable old protocols, import a cipher template on every server, or turn the logging off."

TL;DR

  • Read which side logged it. 36887 means the alert came from the peer; 36888 means this computer sent it. Same number, opposite directions: a 36887 with 70 on a client means the server refused this client's version; a 36888 with 70 on a server means this server refused a client's version (Step 2).
  • The alert number is the reason. Microsoft's Schannel table maps each TLS alert to an error code, and Microsoft's archived alert table gives 40 as "Indicates that the sender was unable to negotiate an acceptable set of security parameters given the options available." and 70 as "The protocol version the client attempted to negotiate is recognized, but not supported." (Step 2).
  • The event doesn't name the peer. Find it by time, port, and process, and by a short packet capture if you have to (Steps 3 and 8).
  • Read the protocols that are really enabled. Microsoft: "For Windows 2012 R2, Windows 8.1, and later operating systems, TLS 1.2 is enabled by default. Thus, the following registry values aren't displayed unless they were set with different values." An empty Protocols key means OS defaults, and the defaults differ by version (Step 4).
  • 36874 is a cipher suite problem. Microsoft's Server 2022 page: some suites "are not enabled by default in Windows Server 2022 23H2 and later", and a hardening template can remove the rest. Compare Get-TlsCipherSuite on both sides (Step 5).
  • Applications pick versions too. Microsoft: "Since .NET Framework is dependent on Schannel on Windows, the operating system dictates which versions can be negotiated and which version will be used." Unless the app hardcodes one, or an old .NET target leaves strong crypto off (Step 6).

Where in the chain did it break?

Step What should be true Typical symptom when it breaks
1. Symptom captured Which computer logs which event IDs, how often, since when, and what stopped working at the same minute "Schannel errors on APP02" with no event ID, no alert number, and no failing connection named
2. Event and alert read The event ID says who sent the alert; the alert number says why; the description is copied whole Every Schannel error treated as "TLS is broken" and fixed by enabling everything
3. Peer and process The remote address, port, and local process at the failing minute are known Hundreds of events from a scanner or one monitoring probe mistaken for the business failure
4. Protocol versions Each side has at least one TLS version enabled that the other side also has enabled A server with TLS 1.0 and 1.1 disabled and an old client or appliance that offers nothing newer
5. Cipher suites Each side has at least one suite enabled for the negotiated version that the other side also offers A hardening template or a newer default list removed the only suite an old peer offers
6. Application The app lets the OS choose the version, or picks a current one A .NET app or a vendor agent hardcoded to TLS 1.0, or WinHTTP on an old OS without TLS 1.2
7. Certificate The alert isn't a certificate alert (42 to 49), or the certificate problem is read separately An expired, untrusted, or wrong-name certificate chased as a cipher problem
8. Handshake trace The Client Hello and Server Hello (or the alert) are captured for the failing peer Guessing at both sides' lists instead of reading the one the client sent
9. Change One link fixed on the side that needs it, with the reason written down TLS 1.0 re-enabled, a cipher template imported, and .NET keys changed on every server at once
10. Proof The same peer connects, the same events stop, and it still works after a reboot and a policy refresh Works until the next Group Policy refresh puts the old cipher list back

Step 1: Capture the symptom (read-only)

Write these on the ticket first:

Fact Why it matters
The computer that logs the events, and its role Web server, SQL Server, Exchange, domain controller, app server, RD host, or a client: the role tells you which side of the handshake it plays for each connection
Which event IDs: 36887, 36888, 36874, or a mix They point in different directions (Step 2); a mix on one box often means it's both a client and a server for different connections
The alert number and the error state in the description The number is the reason; the error state is useful when you open a case, and Microsoft's pages don't list what each one means (our reading of what we found)
How many, how often, and since when A steady stream all day is usually a scanner, a monitor, or one misconfigured peer; a burst that starts at a change window is that change
What stopped working at the same minute An app integration, a SQL connection, a mail flow, an agent check-in, or nothing at all; nothing at all is a finding too
What changed Patching, an in-place upgrade, a TLS 1.0 and 1.1 shutdown, a cipher suite GPO, a hardening tool, a new load balancer or proxy, a new partner endpoint, or a new certificate
Who owns the other side A Windows box you can read, an appliance, a SaaS API, or a partner: it decides whether you can fix that side or have to work around it on yours

Then branch on what you see:

What you see What it usually means (our reading unless noted) Start at
36887 with 70 on a client or app server The server refused the version this computer offered; this side's highest enabled version (or the app's) is too old for the server Steps 4 and 6 on this side
36888 with 70 on a server This server refused a client's version; some client still offers only TLS 1.0 or 1.1 Step 3 to find the client, then Step 4
36874, often with 36888 and 40, on a server No common cipher suite; Microsoft's 36874 text says "none of the cipher suites supported by the client application are supported by the server." Step 5
36887 with 40 on a client The server couldn't agree on parameters with what this client offered: suites, curves, or signature algorithms Steps 5 and 8
36887 or 36888 with 20 Microsoft's resumption article lists alert code 20 with Extended Master Secret enforcement on resumption Step 5 (the TLS_DHE and EMS row)
Alert 42 to 49, or 36882 or 36884 next to it A certificate alert, not a protocol or cipher mismatch Step 7
Alert 10 at a steady rate from many addresses Often something speaking non-TLS to a TLS port, or a scanner; find the source before changing anything Step 3
It started right after a cipher suite GPO or a hardening tool ran That change removed a suite or a version a peer needed Steps 4 and 5, then the GPO
It started after an OS upgrade to Windows Server 2022 or later Newer builds ship different default suite lists and TLS 1.0 and 1.1 defaults Steps 4 and 5
Only one .NET app or one vendor agent fails; the browser works The app is choosing an old version, not Windows Step 6

Step 2: Read the event and the alert number (read-only)

Pull the Schannel events from the System log with their full text, newest first. The alert number is in the message, so read the message, not just the ID:

# Read-only: the last 24 hours of the Schannel handshake events, full message
Get-WinEvent -FilterHashtable @{ LogName='System'; ProviderName='Schannel'; Id=36887,36888,36874; StartTime=(Get-Date).AddHours(-24) } |
  Select-Object -Property TimeCreated, Id, Message |
  Format-Table -AutoSize -Wrap

# Read-only: how many of each event and alert number, to see whether one pattern dominates
Get-WinEvent -FilterHashtable @{ LogName='System'; ProviderName='Schannel'; Id=36887,36888,36874; StartTime=(Get-Date).AddHours(-24) } |
  Select-Object -Property Id, @{ Name='Alert'; Expression={ if ($_.Message -match 'code is (\d+)') { $Matches[1] } } } |
  Group-Object -Property Id, Alert |
  Sort-Object -Property Count -Descending |
  Select-Object -Property Count, Name

Then match it against Microsoft's descriptions. The event texts below are the ones Microsoft prints in its own articles; your build may word them slightly differently:

Event Microsoft's text or description (excerpt) What it tells you (our reading unless noted)
36887 "A fatal alert was received from the remote endpoint. The TLS protocol defined fatal alert code is 20." (Microsoft's resumption article, with code 20) The peer sent the alert; the cause is on how this side's offer looked to the peer. Microsoft's symbolic name: SSLEVENT_RECEIVE_FATAL_ALERT
36888 "A fatal alert was generated and sent to the remote endpoint. This may result in termination of the connection. The TLS protocol defined fatal error code is 40. The Windows SChannel error state is 1205." (Microsoft's SQL Server TLS 1.2 article) This computer refused something the peer sent. Symbolic name: SSLEVENT_GENERATE_FATAL_ALERT
36874 "An TLS 1.2 connection request was received from a remote client application, but none of the cipher suites supported by the client application are supported by the server. The SSL connection request has failed." (same SQL Server article) This server and that client have no cipher suite in common for that version. The older Schannel reference shows the same text for SSL 3.0

Two details from Microsoft's Schannel reference are worth carrying into the ticket. For 36874, it says "This error message could occur when the client application, such as a web browser is using a version of the SSL protocol not supported on the server, causing the connection cannot be made." and its user action is "Investigate the values listed under HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols" (Step 4). For both alert events, it says "With a fatal error, the connection is closed immediately." Microsoft's 36887 description is written from a client's view ("from the server it was communicating or negotiating with"); on a server, a 36887 means a client sent the alert (our reading).

Now read the alert number. Microsoft's Schannel table says "Schannel returns the following error messages when the corresponding alert is received from the Transport Layer Security (TLS) or Secure Sockets Layer (SSL) protocols." The descriptions in the third column are from Microsoft's archived alert-code table, which combines the Microsoft documentation with the TLS RFC:

Alert Microsoft's alert name and Schannel error code Description (Microsoft's archived alert table) Where to look (our reading unless noted)
10 SSL3_ALERT_UNEXPECTED_MESSAGE, SEC_E_ILLEGAL_MESSAGE 0x80090326 "Received an inappropriate message This alert should never be observed in communication between proper implementations." A non-TLS client on a TLS port, a scanner, or a middlebox; Step 3 first
20 TLS1_ALERT_BAD_RECORD_MAC, SEC_E_MESSAGE_ALTERED 0x8009030F "Received a record with an incorrect MAC. This message is always fatal." Microsoft's resumption and Extended Master Secret article; Step 5
40 SSL3_ALERT_HANDSHAKE_FAILURE, SEC_E_ILLEGAL_MESSAGE 0x80090326 "Indicates that the sender was unable to negotiate an acceptable set of security parameters given the options available. This is a fatal error." Cipher suites, curves, or signature algorithms; Steps 5 and 8
42 TLS1_ALERT_BAD_CERTIFICATE, SEC_E_CERT_UNKNOWN 0x80090327 "There is a problem with the certificate, for example, a certificate is corrupt, or a certificate contains signatures that cannot be verified." Step 7
45 TLS1_ALERT_CERTIFICATE_EXPIRED, SEC_E_CERT_EXPIRED 0x80090328 "Received a certificate has expired or is not currently valid." Step 7
46 TLS1_ALERT_CERTIFICATE_UNKNOWN, SEC_E_CERT_UNKNOWN 0x80090327 "An unspecified issue took place while processing the certificate that made it unacceptable." Step 7
48 TLS1_ALERT_UNKNOWN_CA, SEC_E_UNTRUSTED_ROOT 0x80090325 "Received a valid certificate chain or partial chain, but the certificate was not accepted because the CA certificate could not be located or could not be matched with a known, trusted CA." Step 7
70 TLS1_ALERT_PROTOCOL_VERSION, SEC_E_UNSUPPORTED_FUNCTION 0x80090302 "The protocol version the client attempted to negotiate is recognized, but not supported. For example, old protocol versions might be avoided for security reasons. This message is always fatal." Protocol versions on both sides and in the app; Steps 4 and 6
71 TLS1_ALERT_INSUFFIENT_SECURITY (Microsoft's spelling), SEC_E_ALGORITHM_MISMATCH 0x80090331 "Failed negotiation specifically because the server requires ciphers more secure than those supported by the client." The client's suite list; Step 5
80 TLS1_ALERT_INTERNAL_ERROR, SEC_E_INTERNAL_ERROR 0x80090304 "An internal error unrelated to the peer or the correctness of the protocol makes it impossible to continue, such as a memory allocation failure." The side that sent it, not the negotiation
90 TLS1_ALERT_USER_CANCELED, SEC_E_UNFINISHED_CONTEXT_DELETED 0x80090333 "Cancelled handshake for a reason that is unrelated to a protocol failure." Usually the application closing the connection; often noise

One more read in this step: if the app reports a Win32 error such as 0x80090331 or 0x80090326 instead of an alert number, the middle column is the map back to the alert. Microsoft's SQL Server article shows the same pairing in the SQL error log: "0x80090331(The client and server cannot communicate, because they do not possess a common algorithm.)" next to the 36888 and 36874 above.

Step 3: Find the peer and the process (read-only, plus one optional logging change)

The alert events don't name the remote address or the application (our reading of the messages Microsoft quotes above), so line them up with what was connecting at that minute. On the computer that logs them:

# Read-only: who this server is talking to on the TLS ports you care about, and which process owns each connection
Get-NetTCPConnection -LocalPort 443, 636, 1433, 3389 -State Established |
  Select-Object -Property LocalPort, RemoteAddress, RemotePort, OwningProcess |
  Sort-Object -Property LocalPort, RemoteAddress

# Read-only: outgoing TLS connections from this box (it's the client here), with the process name
Get-NetTCPConnection -RemotePort 443 -State Established |
  ForEach-Object { [pscustomobject]@{ RemoteAddress = $_.RemoteAddress; OwningProcess = $_.OwningProcess; Process = (Get-Process -Id $_.OwningProcess).ProcessName } } |
  Sort-Object -Property Process, RemoteAddress

A failed handshake doesn't stay connected, so this shows who normally connects, not the failure itself (our reading). Put it next to the evidence that does carry addresses and times: the application's own log, IIS logs on a web server, the SQL Server error log, the firewall or load balancer log, and the vendor's error. Microsoft's TLS 1.0 paper lists "IIS custom logging to correlate client IP/user agent string, service URI, TLS protocol version and cipher suite." as one of its tools for finding old clients on a web server.

Two patterns to separate before you change anything (our reading):

Pattern What it usually is
A steady rate of the same event and number from many addresses, all day A vulnerability scanner, a monitoring probe that tests old protocols, or internet noise on a published port
A burst that starts at a change window, with one app or one partner failing The business failure; that peer and that change are the ticket
The same address every few minutes One agent, appliance, or scheduled job retrying with the same offer
Events only on the client side, none on the server you own The other side is a SaaS API, an appliance, or a load balancer; you can only change your offer

If you still can't tell which handshakes succeed and with what, Schannel can log the successful ones too. Microsoft: "There are eight logging levels for Schannel events saved to the system event log and viewable using Event Viewer." and "The default value for Schannel event logging is 0x00000001 in Windows, which means that error messages are logged." At the informational levels, Event 36880 records each successful handshake, and Microsoft's reference says for it: "The negotiated cryptographic parameters are protocol, cipher, cipher strength, MAC, exchange, and exchange strength." That's a change, not a read, and it needs a restart: "You must reboot your device after changing the logging level." Raise it for the investigation only, and put it back to 1 afterwards (Step 9):

Value Microsoft's description
0 No events
1 Error events
2 Warning events
3 Error and Warning events
4 Informational and Success events
5 Error, Informational, and Success events
6 Warning, Informational, and Success events
7 Error, Warning, Informational, and Success events
# Read-only: the current Schannel event logging level (no value or 1 means errors only)
Get-ItemProperty -Path 'HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL' -Name EventLogging -ErrorAction SilentlyContinue

On a busy server, 5 or 7 writes an event for every handshake; pick a quiet window, or rely on Step 8's capture instead (our reading).

Step 4: Which protocol versions are enabled on each side? (read-only)

Read the SCHANNEL Protocols key on every Windows side you own, and the OS version, because an empty key means "OS defaults" and the defaults depend on the build:

# Read-only: the OS version (Microsoft's example property filter)
Get-ComputerInfo -Property "*version"

# Read-only: every protocol subkey that exists under SCHANNEL\Protocols and its values
Get-ChildItem -Path 'HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols' -Recurse |
  ForEach-Object { Get-ItemProperty -Path $_.PSPath } |
  Select-Object -Property PSChildName, PSParentPath, Enabled, DisabledByDefault

How to read it. Microsoft's TLS registry reference says the version subkeys live under HKLM SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols with names like TLS 1.2\Server and TLS 1.2\Client, set "separately for the protocol client and server roles". An Enabled value of 1 overrides the default to on; 0 overrides it to off, and then "Disabled: Schannel SSP doesn't negotiate this protocol version regardless of the settings the SSPI caller might specify." Microsoft's Entra and .NET pages also use a DisabledByDefault value under the same subkeys (0 or 1); Microsoft's .NET page says "Under Client and Server, you can create DWORD values DisabledByDefault (0 or 1) and Enabled (0 or 1)." Read both if they exist.

What you find What it means (our reading unless noted)
No Protocols subkeys at all, or none for the version in question OS defaults; Microsoft: "For Windows 2012 R2, Windows 8.1, and later operating systems, TLS 1.2 is enabled by default."
TLS 1.0\Server and TLS 1.1\Server with Enabled 0 on the server A deliberate shutdown; an old client that offers only those gets alert 70 (36888 here, 36887 there)
TLS 1.2\Client with Enabled 0, or DisabledByDefault 1, on the client This side can't, or won't by default, offer TLS 1.2; any server that requires it refuses (Step 9)
Only Server subkeys set, no Client The box still offers old versions when it is the client; that's the half the alerts on this box may be about
TLS 1.3 subkeys on Windows Server 2019 or earlier Microsoft: "Enabling TLS 1.3 on earlier versions of Windows is not a safe system configuration."
Values present on one node of a farm and not the others A manual change or a tool run on one server; the failures follow the load balancer

Microsoft's own pages don't agree on one default worth knowing. The Schannel protocols page shows TLS 1.0 and 1.1 enabled by default on Windows Server 2022 and 2025 and says "Starting with Windows 11 Insider Preview releases in 2024, TLS versions 1.0 and 1.1 will be disabled by default."; the SQL Server TLS article says "On modern Windows releases (Windows 11, Windows Server 2022, and later), TLS 1.0 and TLS 1.1 are disabled by default." Don't settle it from a table: read the registry on the box, and test what it negotiates (Steps 8 and 10).

Windows version (Microsoft's protocols table) TLS 1.0 TLS 1.1 TLS 1.2 TLS 1.3
Windows 7 / Windows Server 2008 R2 Enabled Disabled Disabled Not supported
Windows 8 / Windows Server 2012 Enabled Enabled Enabled Not supported
Windows 8.1 / Windows Server 2012 R2 Enabled Enabled Enabled Not supported
Windows 10 1607 / Windows Server 2016 Enabled Enabled Enabled Not supported
Windows 10 1809 / Windows Server 2019 Enabled Enabled Enabled Not supported
Windows Server 2022 Enabled Enabled Enabled Enabled
Windows Server 2025 Enabled Enabled Enabled Enabled

(Microsoft's table has separate client and server columns; they match for these rows.) If the protocol settings were changed recently, Microsoft notes that services reuse credential handles: "In order to get these applications to reacquire their credential handles, an application, or service restart might be required." A box that "already has TLS 1.2 enabled" but still fails may simply not have been restarted since.

Step 5: Which cipher suites does each side have, and who controls the list? (read-only)

For 36874 and most 40s, compare the suite lists. On each Windows side:

# Read-only: the enabled TLS cipher suites in priority order
Get-TlsCipherSuite | Format-Table -Property Name

# Read-only: just the suites whose names contain a string (case sensitive)
Get-TlsCipherSuite -Name ECDHE | Format-Table -Property Name

# Read-only: is the list set by Group Policy? (a value here means policy owns the order)
Get-ItemProperty -Path 'HKLM:\SOFTWARE\Policies\Microsoft\Cryptography\Configuration\SSL\00010002' -Name Functions -ErrorAction SilentlyContinue

# Read-only: the local list Microsoft's SQL Server article reads when no trace is available
Get-ItemPropertyValue -Path 'HKLM:\System\CurrentControlSet\Control\Cryptography\Configuration\Local\SSL\00010002\' -Name Functions

Microsoft's notes on these reads: Get-TlsCipherSuite "gets an ordered collection of cipher suites for a computer that Transport Layer Security (TLS) can use." and, for -Name, "The name match is case sensitive." (so -Name aes returns nothing). The cipher suite Group Policy writes to SOFTWARE\Policies\Microsoft\Cryptography\Configuration\SSL\00010002, and Microsoft's Exchange guidance warns that you "can't configure them manually by using the Enable-TlsCipherSuite or Disable-TLSCipherSuite cmdlets if they were already configured via GPO or if the Functions registry entry already exists under the HKLM:\SOFTWARE\Policies\Microsoft\Cryptography\Configuration\SSL\00010002 path."

The lists are different on different builds, and that's where many 36874s come from:

Finding What it means (our reading unless noted)
Server is Windows Server 2022 23H2 or later and the client is old Microsoft: "The following cipher suites from the table above are not enabled by default in Windows Server 2022 23H2 and later: TLS_RSA_WITH_3DES_EDE_CBC_SHA, TLS_DHE_RSA_WITH_AES_256_GCM_SHA384, and TLS_DHE_RSA_WITH_AES_128_GCM_SHA256." An old peer that offered only those now has nothing in common
A policy Functions value exists Group Policy owns the order; local cmdlet changes won't stick, and the GPO is the place to read and change (Step 9)
The list is much shorter than Microsoft's default page for that build A hardening tool or a template trimmed it; compare it with Microsoft's default list for that version
Both sides run different Windows versions and both offer TLS_DHE_* suites Microsoft's SQL article: "Those Windows versions handle Diffie-Hellman key exchange inside TLS differently, which can cause the handshake to fail." Its fix is to remove the TLS_DHE_ suites from the policy on the affected side
Intermittent failures with a non-Windows peer when a TLS_DHE_* suite is negotiated, alert 20 in the event Microsoft's resumption article: such connections "might intermittently fail approximately 1 out of 256 attempts" against peers without Extended Master Secret; it lists removing the TLS_DHE_* suites on the client as one mitigation
The peer is Microsoft Entra ID or another Microsoft cloud endpoint and the client offers 3DES only Microsoft's Entra page lists "3DES cipher suite (TLS_RSA_WITH_3DES_EDE_CBC_SHA)" with TLS 1.0 and 1.1 among the protocols and ciphers Microsoft Entra ID stops supporting
SHA-512 or MD5 signed certificate on a SQL Server endpoint with TLS 1.2 Microsoft's SQL article: "If the certificate uses a weak hash (thumbprint) algorithm like MD5, SHA224, or SHA512, it doesn't work with TLS 1.2 and causes the error." It shows up as 36888 with 40 and a 36874

Two more Microsoft points that explain "it worked on the old server". The ordering advice: "Updating the registry settings for the default priority ordering isn't supported and may be reset with servicing updates." So a hand-edited list can come back to the default after an update. And Enable-TlsCipherSuite's page says "Schannel registry settings and settings specified by means of Security Support Provider Interface (SSPI) by each app can override CNG Cryptographic Configuration." An application can narrow the list further than Get-TlsCipherSuite shows.

Step 6: Is the application choosing the version? (read-only)

If one application fails while the browser and other tools on the same box connect to the same endpoint, read the application layer. For .NET Framework apps, Microsoft's rule is that the OS decides unless the app or an old default says otherwise:

# Read-only: is .NET Framework 4.6.2 or later installed? (Microsoft's check; True or False)
(Get-ItemPropertyValue -LiteralPath 'HKLM:SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full' -Name Release) -ge 394802

# Read-only: the .NET strong crypto and system-default values, 64-bit and 32-bit
'HKLM:\SOFTWARE\Microsoft\.NETFramework\v4.0.30319', 'HKLM:\SOFTWARE\Wow6432Node\Microsoft\.NETFramework\v4.0.30319',
'HKLM:\SOFTWARE\Microsoft\.NETFramework\v2.0.50727', 'HKLM:\SOFTWARE\Wow6432Node\Microsoft\.NETFramework\v2.0.50727' |
  ForEach-Object { Get-ItemProperty -Path $_ -ErrorAction SilentlyContinue } |
  Select-Object -Property PSPath, SchUseStrongCrypto, SystemDefaultTlsVersions

# Read-only: the WinHTTP default secure protocols value, if one is set
Get-ItemProperty -Path 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Internet Settings\WinHttp' -Name DefaultSecureProtocols -ErrorAction SilentlyContinue
Finding What Microsoft says What it means (our reading unless noted)
SchUseStrongCrypto missing on an app that targets .NET Framework 4.5.2 or earlier "If your app targets .NET Framework 4.5.2 or earlier versions, the key defaults to 0. In that case, you should explicitly set its value to 1." Old targets don't use strong crypto by default; they can offer old versions a modern server refuses (alert 70)
SystemDefaultTlsVersions missing or 0 "A value of 1 causes your app to allow the operating system to choose the protocol. A value of 0 causes your app to use protocols picked by the .NET Framework." The framework, not the OS, picks the version for that app
Values set under v4.0.30319 but not under Wow6432Node Microsoft's pages list both paths: 64-bit apps read one, 32-bit apps on 64-bit Windows read the other A 32-bit agent or tool still uses the old behavior
App code or config sets a specific protocol "Do not use SslProtocols.Default, because it sets TLS version to SSL3 and TLS 1.0, both of which are obsolete." Hardcoding; Microsoft's TLS 1.0 paper: "Hardcoding here means that the TLS version is fixed to a version that is outdated and less secure than newer versions." Only a code or config change fixes it
WinHTTP DefaultSecureProtocols missing on Windows Server 2012 or earlier Microsoft's Configuration Manager page: for those versions, "By default in Windows, this value is 0x0A0 to enable SSL 3.0 and TLS 1.0 for WinHTTP." WinHTTP callers on that OS don't offer TLS 1.2 until the update and the value are in place
The app is a PowerShell script on Windows PowerShell 5.1 For Invoke-WebRequest -SslProtocol: "This feature was added in PowerShell 6.0.0 and support for Tls13 was added in PowerShell 7.1." Windows PowerShell 5.1 runs on .NET Framework, so the same values apply; test a specific version from PowerShell 7 (Step 10)

The two .NET values only affect what this box offers as a client. Microsoft: "This registry setting affects only client (outgoing) connections in your application." Server-side protocol choices come from the SCHANNEL settings in Step 4.

Step 7: Is it really a certificate alert? (read-only)

Alerts 42 to 49 aren't about versions or suites. They mean one side didn't accept the other's certificate, and Schannel often logs a certificate event next to them. Microsoft's reference texts for the two you'll see most:

Event Microsoft's message (excerpt) Where to look (our reading unless noted)
36882 "The certificate received from the remote server was issued by an untrusted certification authority." The issuing CA isn't trusted on this side; pairs with alert 48
36884 "The certificate received from the remote server does not contain the expected name." The name the client used isn't in the certificate; a DNS alias or a load balancer name
36881 "The certificate received from the remote server has expired." Pairs with alert 45; renew and rebind
36883 "The certificate received from the remote server has been revoked." Pairs with alert 44; a revoked certificate, or a revocation check failing

On the server side, read which certificate is actually bound and what's in the store:

# Read-only: HTTP.sys certificate bindings (IIS, AD FS, WAP, and other http.sys services)
netsh http show sslcert

# Read-only: the computer's personal store with expiry and thumbprint
Get-ChildItem -Path Cert:\LocalMachine\My | Select-Object -Property Subject, NotAfter, Thumbprint

# Read-only: the same store as certutil prints it
certutil -store My

Microsoft's netsh reference: show sslcert "Lists SSL server certificate bindings along with their associated client certificate policies." If a revocation check is the problem (alert 44 or 46 next to a CRL that can't be reached), Revocation Server Was Offline (0x80092013) covers the CRL side; for a domain controller on 636, the LDAPS post linked in the scope covers the certificate selection. The rest of this post is about 10, 40, 70, 71, and 36874.

Step 8: Capture the handshake (read-only)

When the reads on both sides still don't explain it, look at what was actually sent. Microsoft's SQL Server TLS article describes what to read: "The Client Hello packet advertises all the client cipher suites, and the Server Hello packet returns the one the server picked." and "If there are no matching suites, the server closes the connection instead of sending a Server Hello packet." Packet Monitor is in the box on current Windows builds. On the computer that logs the events, filter to the peer and port, capture the whole packet, reproduce once, and convert:

# Read-only capture: one filter for the peer and port, full packets, NIC level only
pktmon filter remove
pktmon filter add TlsPeer -i 10.20.30.40 -p 443
pktmon start --capture --comp nics --pkt-size 0

# ...reproduce the failure once, then stop and convert to pcapng for Wireshark
pktmon stop
pktmon etl2pcap PktMon.etl --out tls-peer.pcapng
pktmon filter remove

Microsoft's notes on those switches: a packet must "match all conditions specified in at least one filter"; --comp can be "NICs only (nics)"; for --pkt-size, "To always log the entire packet, set this to 0. Default is 128 bytes."; the default log file is PktMon.etl; and after conversion "These logs can be analyzed using Wireshark (or any pcapng analyzer)." A 128-byte default cuts off most of a Client Hello, so the 0 matters (our reading).

What the capture shows What it means (our reading unless noted)
Client Hello offers only TLS 1.0 or 1.1, then an alert from the server The client's version is too old for the server (alert 70); fix the client side (Steps 4, 6, and 9)
Client Hello offers TLS 1.2, the server closes without a Server Hello No suite in common; that's Microsoft's no-match case and the 36874 on the server
Server Hello arrives, then an alert after the certificate A certificate alert (Step 7), not a version or suite problem
No Client Hello at all, just a TCP connection and an alert 10 Something sent non-TLS data to the TLS port, or a middlebox interfered
The client's offer differs from what Get-TlsCipherSuite lists on that box The app narrowed or set its own list (Step 6), or a proxy or inspection device rewrote the handshake

Capture files can contain addresses and names from your network; store them like logs, and delete them when the ticket closes (our reading).

Step 9: Change one link (a change)

By now you know which side is old or narrow, and on which setting. Change that, on that side, and write down why. Microsoft's caution on the SCHANNEL registry applies to every item here: "We recommend that you don't directly edit the registry unless there's no other alternative." Prefer the GPO or the vendor's update where one exists.

A client (or an app server acting as a client) can't offer TLS 1.2. On Windows Server 2012 R2 and later, TLS 1.2 is on by default, so look for an explicit Enabled 0 or DisabledByDefault 1 from Step 4 and remove its cause. If you have to set it, this is Microsoft's form from its Exchange TLS guidance, followed by a restart:

# Change: enable TLS 1.2 for client and server connections (Microsoft's Exchange form); restart afterwards
New-Item -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols" -Name "TLS 1.2" -ErrorAction SilentlyContinue
New-Item -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols\TLS 1.2" -Name "Client" -ErrorAction SilentlyContinue
New-Item -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols\TLS 1.2" -Name "Server" -ErrorAction SilentlyContinue
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols\TLS 1.2\Client" -Name "DisabledByDefault" -Value 0 -Type DWord
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols\TLS 1.2\Client" -Name "Enabled" -Value 1 -Type DWord
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols\TLS 1.2\Server" -Name "DisabledByDefault" -Value 0 -Type DWord
Set-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols\TLS 1.2\Server" -Name "Enabled" -Value 1 -Type DWord

Microsoft's Exchange page: "Make sure to reboot the Exchange Server after the TLS configuration has been applied." The same applies to any server whose services hold credential handles (Step 4). On Windows Server 2012 and earlier, WinHTTP callers also need Microsoft's WinHTTP update and the DefaultSecureProtocols value from Step 6 before they offer TLS 1.2.

A .NET Framework app offers old versions. Prefer the app's own fix (retarget, or remove a hardcoded protocol). If the vendor tells you to use the machine-wide values, these are Microsoft's forms, and they need the app restarted:

# Change: let .NET Framework 4.x inherit the OS protocol defaults and use strong crypto (Microsoft's Exchange form)
Set-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\.NETFramework\v4.0.30319" -Name "SystemDefaultTlsVersions" -Value 1 -Type DWord
Set-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\.NETFramework\v4.0.30319" -Name "SchUseStrongCrypto" -Value 1 -Type DWord
Set-ItemProperty -Path "HKLM:\SOFTWARE\Wow6432Node\Microsoft\.NETFramework\v4.0.30319" -Name "SystemDefaultTlsVersions" -Value 1 -Type DWord
Set-ItemProperty -Path "HKLM:\SOFTWARE\Wow6432Node\Microsoft\.NETFramework\v4.0.30319" -Name "SchUseStrongCrypto" -Value 1 -Type DWord

Microsoft's warning for these: "Setting registry keys affects all applications on the system." And, from the Exchange page: "If the value is set to 1, then .NET Framework 4.x inherits its defaults from the Windows Secure Channel (Schannel) DisabledByDefault registry values." So set Step 4 right first.

A server lost the only suite an old peer offers (36874). If Step 5 showed a policy Functions value, change the order in the GPO, not on the server: Microsoft's path is Computer Configuration > Administrative Templates > Network > SSL Configuration Settings > SSL Cipher Suite Order, and "the list of cipher suites is limited to 1,023 characters." If the list is local, add back the one suite the peer and you agree on, at the bottom, and write down the peer and the reason:

# Change: re-enable one suite at the lowest priority (with no -Position it goes to the bottom of the list)
Enable-TlsCipherSuite -Name 'TLS_RSA_WITH_AES_256_GCM_SHA384'

# Change: remove the TLS_DHE suites on the affected side when two Windows versions fail on Diffie-Hellman
Disable-TlsCipherSuite -Name 'TLS_DHE_RSA_WITH_AES_256_GCM_SHA384'
Disable-TlsCipherSuite -Name 'TLS_DHE_RSA_WITH_AES_128_GCM_SHA256'

Microsoft's Enable-TlsCipherSuite page: "If you do not specify a position in the list, this cmdlet adds it at the lowest position." and "No restart is required for changes to take effect."; Microsoft's Manage TLS page says "Changes to the TLS cipher suite order take effect on the next boot." Plan a restart window anyway (our reading). The suite in the example is one Microsoft lists as enabled by default on Windows Server 2025; use whichever suite your capture shows the peer offering, and treat it as an exception with an owner and an end date until the peer is upgraded (our reading).

An old client hits a server that has TLS 1.0 and 1.1 off (36888 with 70 on the server). Fix the client: upgrade it, enable TLS 1.2 there, or update its driver or agent. Microsoft's SQL Server article lists the server-side alternative only as a stopgap: "As a short-term workaround, ask your system administrators to temporarily enable TLS 1.0 or TLS 1.1 on both the client and the server. Do this only until the components can be upgraded." If you must, do it on that one server, with a date to undo it, not on the estate. When you later finish the shutdown, Microsoft's Configuration Manager guidance gives the order: "Enable these settings on all clients running earlier versions of Windows before enabling TLS 1.2 and disabling the older protocols on the Configuration Manager servers. Otherwise, you can inadvertently orphan them."

Put the logging back. If you raised EventLogging in Step 3, set it back to the default and restart when you're done:

# Change: Schannel event logging back to errors only (Microsoft's default); takes effect after a restart
Set-ItemProperty -Path 'HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL' -Name EventLogging -Value 1 -Type DWord

One change per window. Microsoft's Exchange guidance makes the same point about suites and protocols: "Consider applying the following settings separately from disabling TLS 1.0 and TLS 1.1 to isolate configuration issues with problematic clients."

Step 10: Prove it with the same peer (read-only, and again after a reboot)

Test the same connection that failed, from the same side, then read the events from the time of the change. Do it again after the next restart and policy refresh, because a GPO or a servicing update can put the old list back:

# Read-only, on the client side in PowerShell 7: does a TLS 1.2 request to the same endpoint work?
Invoke-WebRequest -Uri 'https://api.contoso.com/' -Method Head -SslProtocol Tls12

# Read-only: any handshake alerts since the change? (nothing returned is the goal)
$changeTime = Get-Date -Date '2026-10-19 14:00'
Get-WinEvent -FilterHashtable @{ LogName='System'; ProviderName='Schannel'; Id=36887,36888,36874; StartTime=$changeTime } -ErrorAction SilentlyContinue |
  Select-Object -Property TimeCreated, Id, Message

# Read-only, after the reboot: still the protocol values and suite list you meant
Get-ChildItem -Path 'HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols' -Recurse |
  ForEach-Object { Get-ItemProperty -Path $_.PSPath } |
  Select-Object -Property PSChildName, PSParentPath, Enabled, DisabledByDefault
Get-TlsCipherSuite | Format-Table -Property Name

If the peer isn't an HTTPS endpoint (SQL Server, LDAPS, SMTP, an agent), use that application's own connection test and its log. If you raised EventLogging, the 36880 success events for that peer show the negotiated protocol and cipher before you put the level back.

Pass criteria (our reading): the failing application or partner connects through a full business cycle (the nightly job, the morning logon peak); no new 36887, 36888, or 36874 that match that peer's time pattern; the protocol values and the suite list are the same after a reboot and a policy refresh; any exception you added (a suite, a temporarily enabled version) has an owner and an end date in the ticket; and EventLogging is back to 1.

Common false starts

False start Why it doesn't help (our reading unless noted)
Re-enabling TLS 1.0 and 1.1 on every server It doesn't touch a cipher mismatch (40 or 36874), and Microsoft's SQL guidance treats it as "a short-term workaround" on "both the client and the server" until the components are upgraded
Importing a cipher suite template from a hardening tool on every server It changes every server's list at once and can remove the one suite an old peer offers; compare lists first (Step 5)
Setting EventLogging to 0 to stop the noise The failures keep happening; you just stop seeing them. Find the scanner or the peer instead
Treating every 36887 as this server's fault Microsoft: "The error indicates a state in the communication process, not necessarily a problem with the application." Read who sent it
Setting the .NET values to fix a server-side 36888 Microsoft: "This registry setting affects only client (outgoing) connections in your application." Server-side versions come from SCHANNEL
Enabling TLS 1.3 on Windows Server 2019 to get ahead of the next deprecation Microsoft: "Enabling TLS 1.3 on earlier versions of Windows is not a safe system configuration."
Running Enable-TlsCipherSuite on a server whose list comes from a GPO Microsoft's Exchange page: you can't configure them with the cmdlets when policy owns them; change the GPO
Changing Protocols values and not restarting anything Services keep their credential handles; Microsoft says "an application, or service restart might be required."
Hand-editing the default priority order in the registry Microsoft: it "isn't supported and may be reset with servicing updates." Use the GPO, MDM, or the TLS cmdlets
Copying the Protocols key from an old server to a new build Defaults differ by version (Step 4); you may switch off something the new build needs or switch on something it shouldn't use
Reading Get-TlsCipherSuite -Name aes and concluding AES is off Microsoft: "The name match is case sensitive." Use -Name AES

When a change is justified

Finding Prefer Avoid
Client side can't offer TLS 1.2 Remove the explicit disable or set TLS 1.2 Client on that box, restart, then retest Re-enabling TLS 1.0 on the server for it
.NET app on an old target Retarget or remove the hardcoded protocol; machine-wide values only as the documented fallback Setting the .NET values on every server just in case
WinHTTP caller on Windows Server 2012 or earlier Microsoft's WinHTTP update and DefaultSecureProtocols, then plan the OS upgrade Leaving the OS and disabling TLS 1.2 elsewhere
Old client against a server with TLS 1.0 and 1.1 off Upgrade or fix the client; a time-boxed exception on that one server if the business needs it Turning the old versions back on estate-wide
No common suite with one legacy peer One suite re-enabled at the bottom, in the GPO if policy-owned, with an owner and an end date Importing a "compatibility" template that adds every old suite
TLS_DHE failures between Windows versions Remove the TLS_DHE_* suites on the affected side, as Microsoft's SQL and resumption articles describe Disabling ECDHE or the newer suites to force DHE
Scanner or probe causing the stream Identify the source and fix or exclude it in the scanner Lowering EventLogging to hide it
Certificate alert (42 to 49) Fix the certificate, the chain, or the name binding (Step 7) Changing protocols or suites for a certificate problem
GPO-owned cipher list Change the SSL Cipher Suite Order policy, test on one OU first Local cmdlet or registry edits the next refresh overwrites

FAQ

What does Schannel Event 36887 mean?
This computer received a fatal TLS alert from the other side of a connection, and the number in the message is the reason. Microsoft's symbolic name is SSLEVENT_RECEIVE_FATAL_ALERT, and its reference says "The error indicates a state in the communication process, not necessarily a problem with the application." Read which side logged it and the alert number before changing anything (Step 2).

What is fatal alert 40 in a 36887 or 36888?
Alert 40 is handshake_failure. Microsoft's archived alert table describes it as "Indicates that the sender was unable to negotiate an acceptable set of security parameters given the options available." In practice that's usually no cipher suite in common, often with a 36874 on the server; compare Get-TlsCipherSuite on both sides and capture the Client Hello (Steps 5 and 8).

What does fatal alert 70 mean?
Alert 70 is protocol_version: "The protocol version the client attempted to negotiate is recognized, but not supported." On a client (36887), the server refused this client's version; on a server (36888), this server refused a client's version. Read the SCHANNEL Protocols values and the application's own protocol settings on the client side (Steps 4 and 6).

What causes Schannel Event 36874?
A client's offer didn't include any cipher suite the server has enabled. Microsoft's text: "none of the cipher suites supported by the client application are supported by the server." Common causes are a trimmed suite list on the server, a newer server build with fewer default suites, or an old client with only legacy suites (Step 5).

How do I enable Schannel event logging?
Set the EventLogging DWORD under HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL; 1 is the default (errors), 7 logs everything, and Microsoft says "You must reboot your device after changing the logging level." Raise it only for the investigation and set it back to 1 afterwards (Steps 3 and 9).

Related posts

Free tool: SSL handshake failure and protocol version guide on SysAdmin Toolbox, with the SSL certificate checker for the peer's certificate chain.

Free checklist

Re-enabling TLS 1.0 and 1.1 on every server, or importing one cipher suite template across the estate, before anyone read which peer sent which alert, is a change made everywhere at once. So is a Conditional Access policy enforced before anyone read the report-only results. The free Conditional Access pre-enforcement checklist keeps break-glass accounts, pilot groups, and report-only review on one page:

Γ°ΕΈβ€˜β€° https://cashflow4375.gumroad.com/l/ujkqxb?utm_source=devto&utm_medium=article&utm_campaign=aps_first_sale&utm_content=schannel-event-36887-fatal-alert

If you want the rest of the Intune runway written down for the team (enrollment hygiene, compliance phasing, break/fix cards and read-only PowerShell snapshots), the Intune & M365 Admin Starter Pack pairs with this triage: https://cashflow4375.gumroad.com/l/joonf?utm_source=devto&utm_medium=article&utm_campaign=aps_first_sale&utm_content=schannel-event-36887-fatal-alert

Admin Pack Studio; not affiliated with Microsoft. Steps 1-8 and 10 are read-only checks: Get-WinEvent, Get-NetTCPConnection, Get-Process, Get-ComputerInfo, Get-ChildItem and Get-ItemProperty on the SCHANNEL, Cryptography, .NET Framework, and WinHTTP registry keys, Get-ItemPropertyValue, Get-TlsCipherSuite, netsh http show sslcert, certutil -store, a pktmon capture with etl2pcap, and Invoke-WebRequest -Method Head. Raising or restoring Schannel EventLogging, enabling or disabling protocol versions under SCHANNEL\Protocols, setting the .NET SystemDefaultTlsVersions and SchUseStrongCrypto values or the WinHTTP DefaultSecureProtocols value, Enable-TlsCipherSuite, Disable-TlsCipherSuite, the SSL Cipher Suite Order policy, and restarts are deliberate changes. Change one link at a time, prove it with the same peer after a reboot, and check current Microsoft Learn for version-specific behavior.

πŸ“° Read the original article on Dev.to Security

Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes β€” full credit and traffic to the original publisher.