Home › Topics › Core Services: NTP, RADIUS, LDAP/AD › When Logins Break

When Logins Break: Troubleshooting the Authentication Path


There is a particular flavor of dread that arrives with the words "nobody can log in." A dead switch takes down a room; a broken login takes down people — their files, their apps, their meetings — while every device in the building blinks green. And because authentication touches everything, the complaints arrive from everywhere at once. Each points at a different innocent bystander: the Wi-Fi, the VPN, the server, the new laptop, Mercury being in retrograde.


Here is the calming truth: authentication is not magic. It is a chain. A login travels a fixed path through a handful of stations, any of which can break. Each can be tested on its own in about a minute. Troubleshooters who panic treat the outage as one giant mystery. Troubleshooters who look calm are quietly walking the chain, station by station, until they find the broken one.


This guide is the walk. You will learn to scope the failure first (the step that halves the search space before you touch anything). You will learn the chain itself and what each hop contributes, and a synthetic test for every hop. You will also learn the five classic culprits ranked by how often they turn out to be guilty. You will follow a worked real-world-shaped incident from first report to fix. Then comes the part your future self cares about. You will learn how every culprit on the list maps to a monitor you can set up today.


In this guide

  • Scope first: the question that halves the search
  • The chain, drawn out
  • A synthetic test for every hop
  • The classic culprits, ranked
  • A worked incident: "the Wi-Fi is down"
  • Evidence and escalation notes
  • Prevention: wire a monitor to every culprit
  • Where to go next

Scope first: the question that halves the search


Resist the urge to test anything until you can answer one question: who exactly is failing, and who is not? Authentication problems are chain problems, and different failure scopes implicate different segments of the chain. Two minutes of scoping — asking the helpdesk, checking the ticket queue, messaging a colleague at another site — routinely saves an hour of testing the wrong things.


Scope of failureWhat it implicatesWhat it largely clears
One user, everywhereTheir account: locked, expired, disabledThe entire infrastructure
One machine, any userThat machine: its clock, its domain trust, its configServers and services
One application, all usersThe app's own auth wiring: its service account, its directory connectionRADIUS, the edge
Wi-Fi only (wired fine)The RADIUS path from the access points, or the RADIUS server's certificateThe directory core, usually
VPN onlyThe VPN appliance's RADIUS/directory linkInternal auth path
One site onlyThat site's DC, or the WAN path to auth servicesCentral services
Everything, everyoneThe directory itself, or what it stands on: DNS, timeEdge devices

Scope has a second dimension people forget: since when, and with what shape. A hard start at exactly midnight smells like an expiry — certificates and account policies tick over on date boundaries. A hard start the moment a maintenance window opened points at the change. A slow worsening over days — more complaints each morning, retries helping less — is the signature of drift or a filling queue, not a break. And "it only fails sometimes, for some people" usually means a half-dead redundant pair, where luck of the failover decides each user's morning. Write the start time and the shape down before they get fuzzy; they will vote on suspects later.


Notice the diagnostic gold in the contrasts. "Wi-Fi broken but wired logins fine" is practically an arrow drawn on a map. In that case, the shared foundation (directory) is probably healthy. So look at the segment only Wi-Fi uses — the access points' path to RADIUS and the RADIUS server's own trimmings. "Everything broken everywhere" points the opposite direction, at the deep shared layers. Scope is not paperwork; scope is the first test.


The chain, drawn out


Every login in a typical org travels some version of this path:


[client] --> [access device] --> [RADIUS] --> [directory]
 laptop      AP / switch /        the           LDAP / AD
 phone       VPN appliance        gatekeeper    (the DCs)
                                                    |
              ...and underneath every hop:          |
        [ DNS: finding things ]  [ TIME: agreeing ]<+

Read it left to right. The client supplies credentials — and its own clock and configuration, which is why one drifted laptop can fail alone. The access device (an access point, a switch port, the VPN appliance) does no checking itself. It forwards the request to RADIUS and enforces the verdict, contributing its RADIUS settings, shared secret, and timeouts. RADIUS is the gatekeeper that evaluates policy and, almost always, passes the credential question onward. The directory — your domain controllers — holds the actual accounts and gives the final answer. And beneath all four run the two silent utilities. One is name resolution, which every hop uses to find the next one. The other is time agreement, which the credentials themselves depend on. A break at any station stops the train, and every station fails with its own accent — which is exactly what the per-hop tests exploit.


Wired 802.1X (switch port authentication), Wi-Fi, and VPN logins are all this same chain with a different first two boxes. An application checking a password against the directory is the same chain with the middle boxes removed. One mental model, every login flavor.


One complication muddies the picture, so meet it now: caching. Windows laptops cache domain credentials. So people who have logged into their own machine before may get to their desktop just fine during a full directory outage. They may then fail at everything past it. Existing Wi-Fi and VPN sessions coast until they re-authenticate. The result is that a total failure at a deep hop rarely looks total. It looks like a weird partial outage biased toward people who rebooted, arrived late, or came back from lunch. If your scope answers seem contradictory, ask the follow-up: "did it work and then stop, or did it fail fresh?" Cached grace explains most of the contradictions.


A synthetic test for every hop


Now the walk itself. The strategy: test the chain from the deepest shared layer outward when scope says "everything." Test from the failing edge inward when scope says "one door." Either way, each hop gets a direct question it cannot dodge:


# Hop 4+5: clocks first when scope is wide (fast, and a classic)
w32tm /stripchart /computer:dc1.corp.example /samples:3
#   offsets should be well under a second

# Hop 4: does each DC answer a real directory login, quickly?
ldapsearch -H ldaps://dc1.corp.example -D svc-probe@corp.example \
  -w PASSWORD -b dc=corp,dc=example "(sAMAccountName=svc-probe)" dn

# Hop 3: does each RADIUS server accept a real authentication?
radtest svc-probe PASSWORD radius1.corp.example 0 SECRET
radtest svc-probe PASSWORD radius2.corp.example 0 SECRET

# Hop 2: does a real edge device get through?
#   join the test SSID with a test device, or run the VPN
#   client with the probe account — the edge's own view

# Hop 1: is it really "everyone"? one colleague, one other
#   machine, one other site — scope, re-verified

Interpretation is a simple elimination game. If the LDAP binds fail on every DC, stop blaming the Wi-Fi; you have a directory (or deeper — DNS, time) problem. If the directory answers but radtest fails, the break lives in RADIUS or its link to the directory. If RADIUS accepts your test but real devices still fail at the edge, the problem is between the doors and the gatekeeper. Possible causes are shared secrets, firewall rules, or the access device's configuration. Or the cause is something the direct test did not exercise. That is the crack the worked incident below fell through. And keep the two failure flavors straight at every hop. A timeout means "nobody answered" (dead service, blocked path, wrong secret). A reject means "answered, and said no" (account, password, policy). They are different roads; note which one you are on.


Tip: run the tests from where the victims are. A probe that authenticates fine from the server VLAN proves little about a branch office behind a misbehaving WAN link. The chain includes the network path — test the path users actually travel.


The classic culprits, ranked


Authentication outages are not evenly distributed across the possibility space. A handful of causes account for most of the incidents any admin will meet. They are worth knowing by heart, in roughly the order experience says to suspect them:


  • 1. An expired certificate on the authentication server. The reigning champion. Wi-Fi clients validate the RADIUS server's certificate during the login handshake. The day it expires, every properly configured device refuses the network — at midnight, org-wide, with dashboards green. Quick confirm: check the certificate dates on the auth server; check its logs for TLS handshake failures.
  • 2. Clock skew. Time-stamped credentials plus a drifted clock equals "wrong password" for people whose passwords are right. Presents as scattered, machine-following failures — or site-wide if a DC drifted. Quick confirm: offset check against the DCs; anything measured in minutes is your answer.
  • 3. The dead secondary, discovered during primary maintenance. The backup auth server died months ago; nobody noticed because nothing tested it; tonight's planned reboot of the primary just became an outage. Presents as "everything broke the moment maintenance started." Quick confirm: synthetic auth against the secondary by its own address.
  • 4. An expired service account password. The account RADIUS uses to query the directory, or an app uses to bind, hits its password expiry date. The service starts failing quietly — often after the next service restart, days later, maximizing confusion. Quick confirm: the service's own logs ("bind failed", "authentication failure" from the service account), and the account's password-age attributes.
  • 5. A group or policy change. Someone edited a policy, renamed a group, moved accounts between organizational units — and an access rule somewhere stopped matching. Presents as a clean subset of users failing starting at an oddly specific time. Quick confirm: the change log, and comparing one failing user's memberships against one working user's.

The pattern hiding in the list: not one of these is exotic. They are all mundane, predictable, calendar-driven failures — which is precisely why the prevention section at the end of this guide works so well.


A worked incident: "the Wi-Fi is down"


Monday, 8:52. Tickets arrive in a clump: "Wi-Fi down." By 8:57 there are eleven of them. Walk it as the playbook says.


8:57 — scope. Quick questions to the helpdesk channel reveal that wired desktops are logging in fine. The guest network (a simple password, no RADIUS) works. And the VPN — which authenticates against the same RADIUS servers — is fine too. Scope says: only the corporate Wi-Fi, which is the only consumer of the certificate-secured login handshake. The directory is already effectively cleared; two candidate hops remain, with culprit number one waving its hand.


9:03 — per-hop tests. LDAP binds to both DCs: instant, clean (as expected). radtest against both RADIUS servers: Access-Accept, both. Interesting — the gatekeeper answers a direct, simple test. But a test laptop cannot join the corporate SSID; it fails during the secure handshake, before a password is even seriously discussed. A direct test that passes while the edge fails points at the layer the direct test skips: the TLS tunnel, and the certificate that anchors it.


9:10 — confirm. One look at the RADIUS server's certificate: expired at midnight, Sunday into Monday, as certificates almost ceremonially do. The server logs agree — a wall of TLS handshake failures starting at 00:00, roughly eight hours of them. The failures were silent because nobody works at midnight and nothing was watching the expiry date.


9:12 to 9:35 — fix and verify. Issue and install a replacement certificate (internal CA; a public renewal takes longer, which is its own lesson about lead time). Restart the service, watch the test laptop join, and watch the ticket clump stop growing. Post a plain-language status: cause found, fixed, brief reconnects possible. Total incident: about forty minutes — of which thirty-five were only necessary because the expiry date, knowable for a year, was watched by no one.


The lesson worth framing: the direct RADIUS test passed while real clients failed, and that mismatch was not a nuisance — it was the diagnosis. A synthetic test only proves the path it actually exercises. And a simple scripted authentication does not build the same secure tunnel a Wi-Fi client builds, so it sails past a dead certificate. That has two consequences. During an incident, treat "direct test passes, edge fails" as an arrow pointing at whatever the direct test skipped. When designing monitoring, make at least one probe authenticate the way real clients do. Or, cheaper still, watch the certificate itself. That is exactly what would have turned this whole incident into a calendar reminder three weeks earlier.


Tip: while testing, use your dedicated probe account — never a real user's credentials, and never rapid-fire guesses. Account lockout policies cannot tell diligent troubleshooting from an attack, and locking out the CFO mid-incident adds a second incident to your first one.


Evidence and escalation notes


Two habits separate a well-run auth incident from a chaotic one, and neither requires seniority. First, write as you go: the exact time symptoms started, the scope answers, each test you ran, its result, and the timestamps. Authentication incidents cross specialty borders more than any other kind. The moment you hand off to a directory admin, a vendor, or an MSP, that little log makes the difference. It separates a ten-minute handoff from starting the investigation over. "LDAP binds pass on both DCs, radtest passes on both servers, EAP fails at every AP, TLS errors began at 00:00" is a gift; "Wi-Fi broken, please advise" is a Monday.


A useful escalation package fits on an index card:


  • Start time and shape of the failure, in one sentence.
  • Scope: who fails, who does not — including the surprising survivors.
  • Per-hop test results, with reject-versus-timeout noted for each.
  • The two or three most relevant log lines, verbatim, with timestamps.
  • What you changed while investigating (including restarts), and when.

Second, ask "what changed?" out loud — against the change log, the patch schedule, and last night's maintenance window. But treat the answer as a lead, not a verdict. Time-driven failures (certificates, password expiries, drift crossing a threshold) love to disguise themselves as change-driven failures because they surface the morning after some unrelated change. The timeline in your notes is the antidote: an error wall starting at exactly midnight indicts a date, not a patch.


Prevention: wire a monitor to every culprit


Now the satisfying part. Reread the ranked list and notice what the culprits have in common: every one is visible in advance to a cheap, specific monitor. This is unusual — plenty of outages genuinely ambush you — but authentication fails on schedules and calendars, and calendars can be watched:


CulpritThe monitor that defuses it
Expired auth server certificateCertificate expiry checks with weeks of warning — the certificate monitoring guides cover the whole discipline
Clock skewOffset checks on DCs and auth servers, alerting in seconds of drift (see NTP and clock drift)
Dead secondarySynthetic authentication against each server by its own address (see RADIUS monitoring), plus a scheduled failover drill
Service account password expiryA watched list of service accounts and their password ages — alert a month out, not the morning of
Group/policy change breakageChange review plus a synthetic login that exercises the real policy path, so a bad change fails a probe before it fails a person

Add the directory-layer checks from the LDAP and AD health guide underneath, and something quietly excellent happens to this entire playbook. It stops being a troubleshooting procedure and becomes a dashboard row you glance at. The chain is still there, and someday something novel will still break it. But the five classics, the ones that cause most of the pain, will announce themselves to you weeks early. They will use the polite voice of a warning instead of the 8:52 clump of tickets.


Where to go next


You have the whole method now. Scope to halve the search, use the chain as your map, and ask a synthetic question for every hop. Check the five culprits in order of guilt and take notes as you go. Wire a monitor to each classic so the next incident is a warning instead. For the bigger picture of why these services deserve first-class monitoring, start at the dependency iceberg. It also explains how they hide beneath every app your users touch. Find the rest of the series at Core Services: NTP, RADIUS, LDAP/AD.


Put this into practice with SysPeep Monitor

Half this playbook can run on autopilot. SysPeep Monitor watches the servers along your authentication chain — DCs, RADIUS hosts, and the network between them. It uses health checks over WMI, SNMP, and SSH, and alert rules with real thresholds. Its dependency logic points at the broken hop instead of paging you for every symptom downstream.

Download Free TrialLearn About SysPeep