Distinguishing NTLM and Kerberos Authentication

A domain account can authenticate through more than one kind of exchange. Distinguishing NTLM and Kerberos authentication means identifying the mechanism, not merely observing that a connection succeeded. Before testing access to a lab server, ask what that server and client wil…

A domain account can authenticate through more than one kind of exchange. Distinguishing NTLM and Kerberos authentication means identifying the mechanism, not merely observing that a connection succeeded. Before testing access to a lab server, ask what that server and client will actually use. We will contrast challenge-and-response with ticket-based authentication, then connect each mechanism to its prerequisites and evidence.

If the answer is NTLM, the exchange is based on challenge and response. If the answer is Kerberos, the client normally presents a ticket issued through the domain’s authentication infrastructure. Those aren’t interchangeable descriptions of the same event. They imply different prerequisites, artifacts, failure conditions, and evidence.

The practical goal isn’t to memorize two protocol names. It’s to recognize what material a proposed technique needs and what observation would show that the technique actually worked. A tool that accepts a password hash is doing something different from one that requests or presents a Kerberos ticket. If you can’t explain that difference, a promising result can send you down the wrong path.

Start by bounding the assessment. Record the lab target, the identity you currently control, the access that identity already has, and the question you’re trying to answer. Perhaps the question is whether the account can authenticate to a particular service.

Perhaps you’re investigating whether discovered credential material is usable through NTLM. Or perhaps you need to determine whether the domain will issue a Kerberos service ticket for a registered service. Each question calls for different evidence.

Take a baseline before testing. Confirm which host and service you’re addressing, whether you’re using a local or domain identity, and what happens without the proposed authentication material. Then make a prediction.

If the NTLM test succeeds, what resulting access or authenticated identity should appear? If the Kerberos request succeeds, which ticket or service response should exist? This prediction stops a generic success message from becoming your entire conclusion.

Now perform one bounded test in the deliberately vulnerable lab and preserve the exact result. The test might produce authenticated access, an issued ticket, a protocol-specific error, or an ordinary connection failure. Compare that result with the prediction.

Authenticated access supports a stronger conclusion than merely reaching a listening service. A ticket being issued answers one question, while successful acceptance of that ticket by the intended service answers another. Keep those transitions separate.

This is why knowing a command isn’t the same as understanding the technique. A copied command may run while using the wrong identity, contacting the wrong host, or falling back to a protocol you didn’t intend to test. Practical assessment requires you to connect the preconditions, the protocol exchange, the resulting security context, and the next decision. Your notes should preserve that reasoning, not just the command that happened to produce colorful output.

NTLM uses challenge-response authentication. In simplified terms, a client identifies the account it wants to use. The server supplies a challenge. The client calculates a response using credential-derived material and returns that response.

The validating system determines whether the response is correct. The user’s password doesn’t need to travel across the network as plain text during that exchange. For a domain account, validation can involve the domain. For a local account, the target can validate against its own account information.

The important artifact is the response to that particular challenge. A captured challenge-response exchange isn’t automatically the account’s reusable password hash, and it isn’t proof that the password has been recovered. Those forms of material mustn’t be collapsed into one vague idea called credentials. A password, an NTLM password hash, and a captured challenge-response transcript can support different actions under different conditions. When a technique expects one of them, supplying another may fail even though both are associated with the same account.

Pass the hash illustrates why the distinction matters. In an authorized lab, a technique may authenticate through NTLM by using captured password-hash material rather than requiring the operator to know the original password. That doesn’t mean every hash works against every service, or that possession of a hash guarantees useful access. The target must support the relevant authentication path, the account must be valid in that context, and the account must have permission to do something meaningful after authentication.

Kerberos follows a ticket-based model in an Active Directory domain. A domain controller integrates the Key Distribution Center, or KDC, that participates in issuing the tickets used for domain authentication. Instead of treating every service connection as a fresh NTLM challenge-response exchange, a client obtains Kerberos ticket material and presents an appropriate ticket to the requested service. The service then evaluates that ticket in its own context.

There are two useful stages to keep conceptually separate. A client can obtain initial ticket material that supports later ticket requests. It can then request a service ticket for a particular registered service identity.

That service identity is associated with a service principal name. The service ticket is intended for that service, not as a universal token for every system in the domain. Seeing ticket material therefore doesn’t, by itself, prove that a particular server accepted it or that the user gained administrative access.

Kerberoasting depends on this service-ticket mechanism. An authorized domain user may be able to request a service ticket for an account associated with a service principal name. Part of that returned ticket can create an offline password-cracking risk for the service account. The request doesn’t reveal the clear-text password, and obtaining a ticket doesn’t establish that cracking will succeed. The usefulness of the artifact depends on factors such as whether the service identity exists, whether the ticket was actually obtained, and whether the account’s password can be recovered through permitted offline testing.

So the protocol name changes what you look for. With NTLM, relevant evidence may include the challenge-response exchange, the supplied hash material, the validated account, and the access created after authentication. With Kerberos, relevant evidence may include the requested service identity, the issued ticket, the identity represented by it, and whether the intended service accepted it. Neither a tool label nor one positive-looking line proves the entire chain.

Return to the lab account and server. First confirm basic reachability and identify the specific service being tested. Don’t begin by launching broad automation and treating everything it prints as equally trustworthy. A narrow manual test is easier to interpret. It also helps you identify whether the client tried NTLM, attempted Kerberos, or failed before authentication began.

Suppose you have an NTLM password hash for the ordinary domain account. Your hypothesis is that the hash can support NTLM authentication to a permitted service on the lab server. Record the account name, domain context, target, and service.

Then make a bounded authentication attempt using a method that explicitly accepts the required hash material. If it succeeds, verify the resulting identity and determine what the authenticated session can actually do. Authentication as an ordinary user isn’t evidence of administrator privileges.

If the attempt fails, don’t immediately conclude that the hash is wrong or that NTLM is absent. Read the failure closely. Did the client reach the service? Was the domain specified correctly?

NTLM and Kerberos do not describe interchangeable artifacts. A challenge-and-response exchange and a presented Kerberos ticket have different prerequisites and different failure points. Identify the mechanism used by the actual request before drawing a conclusion about the credential or ticket involved.

Did you accidentally use a local-account context? Did the application attempt another authentication method? Was authentication rejected, or did authentication succeed before authorization denied the requested action? Those outcomes may look similar when reduced to the word failed, but they support different next steps.

Change one assumption at a time. Confirm reachability without changing the credential material. Confirm the account format without changing the target.

Use a lower-impact request to separate authentication from the privileged action you originally attempted. Then repeat the bounded test with only the relevant correction. Preserve the first result as well as the corrected one. The failed path shows which assumption was wrong and makes the successful path reproducible.

Now consider the Kerberos side. Your account is valid in the domain, and you want to determine whether a particular service identity has usable ticket material associated with it. Start by confirming the identity and requested service, rather than assuming that any hostname automatically maps to the intended service principal name.

Make the permitted request and preserve the response. An issued service ticket confirms that the ticket request succeeded. It does not prove that you’ve recovered the service account’s password or obtained access to every host where that account appears.

If the request produces no ticket, isolate the prerequisite that remains unverified. The service identity may have been entered incorrectly. The domain authentication infrastructure may be unreachable from your current position.

Your current identity or ticket state may not be what you assumed. The failure may also occur before the KDC evaluates the requested service. Check the relevant identity, network path, request behavior, and protocol state one at a time instead of cycling through unrelated tools.

Successful ticket acquisition still calls for another decision. If your lab objective involves offline testing of the service-ticket artifact, preserve the exact artifact and the account or service context tied to it. If testing doesn’t recover a password, report that honestly.

The ticket request was demonstrated, while password recovery was not. If recovery succeeds within the lab’s rules, validate the credential against the intended authorized target and document what access it produces. Don’t turn password recovery into an unsupported claim of domain-wide control.

A common source of confusion is an application that can use more than one authentication protocol. Reaching a domain service doesn’t prove which model was used. A successful connection made with a password might involve Kerberos when the environment can obtain the right ticket, or NTLM under other conditions. If the protocol matters to your conclusion, capture protocol-specific evidence. Don’t infer it solely from the fact that Windows accepted the account.

A valid password and a working connection still do not identify the authentication protocol. Applications and environments may support more than one path. When the distinction matters, preserve evidence of the path actually used rather than the path you expected.

The reverse mistake is treating every failure as evidence that the proposed path is absent. A name-resolution problem, incorrect service identity, blocked network path, expired or unavailable ticket state, wrong account context, rejected syntax, or insufficient authorization can interrupt the test at different points. Some of those observations concern Kerberos prerequisites. Others occur before either authentication model gets a fair test. Identify the earliest unsupported transition and test that transition directly.

Your report should let another technically competent person understand the chain without relying on your memory. Record the target’s identifying details, the service under test, the account context, and whether the identity was local or domain based. Note the credential material or protocol artifact used. Preserve the exact request or command, meaningful output, relevant screenshots when needed, and the resulting identity or access level. Explain why that result changed your next decision.

For an NTLM result, avoid writing only that pass the hash worked. State what hash material was available, which account it represented, which authorized service accepted the authentication, and what the resulting session could do. If the session lacked administrative rights, say so. If the authentication method wasn’t independently verified, don’t label it NTLM merely because the tool had an option with that name. Separate direct observation from interpretation.

For a Kerberos result, identify the requested service and the ticket artifact you obtained. Distinguish ticket issuance from service acceptance, and distinguish either of those from password recovery. If a service-ticket artifact was tested offline, document the outcome without implying that requesting the ticket alone exposed a password. This level of precision helps a reader see exactly where the chain is strong and where it remains conditional.

Failed tests deserve useful notes too. Capture the error, the conditions under which it occurred, the prerequisite you believed was missing, and the lower-impact check used to examine that prerequisite. Then record the one change that produced a different result. A list of unexplained failures is hard to use. A sequence showing hypothesis, observation, correction, and outcome demonstrates disciplined assessment and helps prevent the same mistake later.

Once the evidence is organized, the next move becomes clearer. Validated NTLM authentication may justify checking what the authenticated identity can access on that specific target. A Kerberos service ticket may justify permitted offline analysis if that is the lab question.

A ticket accepted by a service may support a different access decision. An ambiguous error justifies another focused validation, not a leap to an unrelated attack. The protocol model, the artifact in hand, and the observed outcome should all point in the same direction before you proceed.

NTLM and Kerberos are different authentication systems whose messages, credentials, tickets, and resulting sessions must not be treated as interchangeable. Take the result back to one practical question: Which authentication protocol is active, what credential or ticket material is being used, and what resulting session does it establish? The companion study reference collects the lesson’s explanations and review checks. This lesson was produced by Bare Metal Cyber dot com.

Distinguishing NTLM and Kerberos Authentication
Broadcast by