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-TlsCipherSuiteon 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:\Source:https://dev.to/adminpackstudio/schannel-event-36887-36888-and-36874-fatal-alert-40-or-70-a-read-first-protocol-cipher-suite-48dm