skip to content

What part of a RADIUS packet does the shared secret actually hide, compared with a TACACS+ packet?

level: middleimportance: must knowfreq 64%

answer

  1. scope, not strength
  2. one attribute against a whole body
  3. the header never hides
  4. obfuscation is the specification's own word
  5. no tamper-evidence, no forward secrecy

basics

~20 s

In RADIUS the shared secret hides only the User-Password attribute; the rest, including the user name, travels in the clear. TACACS+ masks its whole body after the 12-byte header — which RFC 8907 calls obfuscation, not encryption.

solid answer

~40 s

RADIUS hides exactly one attribute. The shared secret, together with the request's authenticator, keys a keystream that is combined with `User-Password`; every other attribute — `User-Name`, `NAS-IP-Address`, `Filter-Id`, `Session-Timeout` — is readable by anyone on the path. TACACS+ masks the entire packet body, so the account name, the command being authorized and the argument-value pairs around it are all hidden; only the 12-byte header stays clear. That is a genuine difference in *scope*, and it is the axis the comparison turns on. It is not a difference in strength: **RFC 8907** deliberately calls its body protection *obfuscation* rather than encryption, because it offers no integrity protection and no forward secrecy. Wider coverage, not stronger coverage.

code

pseudocode · 14 lines
pseudocode
// RADIUS Access-Request on UDP port 1812 - what an observer on the path reads
packet header and Request Authenticator ......... clear
User-Name = "j.okonkwo" .......................... clear
NAS-IP-Address ................................... clear
Filter-Id, Session-Timeout (on the reply) ........ clear
User-Password .................................... combined with a keystream keyed by the shared secret

// TACACS+ packet on TCP port 49, classic transport
12-byte header
  version, type, seq_no, flags, session_id, length  clear
body
  account name, prompts, argument-value pairs ..... combined with a pad derived from the shared secret

// the honest limit on both: neither body protection is tamper-evident on its own

go deeper

for a junior

Recall the scope: RADIUS hides one attribute, the password, and TACACS+ hides the whole body after its header. Being able to say which one leaves the account name readable is most of the answer.

for a middle

Explain the mechanism at the level of scope and keying — one attribute combined with a keystream against a pad applied across a whole body — and separate confidentiality from the integrity checks the same secret also keys.

for a senior

Demonstrate the correction: breadth of coverage is not strength. Say out loud that the specification calls it obfuscation, that there is no forward secrecy, and what that implies for where the traffic is allowed to run and how often the key changes.

for a principal

Treat it as an estate-wide exposure question. Decide what a captured management-plane session would reveal about your operators and devices, and price moving both planes onto record-protected transports against leaving decades-old mechanisms on a network you already treat as trusted.

## What the RADIUS shared secret actually covers A RADIUS deployment configures a **shared secret** per network access server. That secret does two different jobs, and conflating them is the most common error in this answer. - **Confidentiality, for one attribute.** The secret is combined with the **Request Authenticator** to produce a keystream, and that keystream is combined with the **`User-Password`** attribute. That is the whole of the confidentiality story in classic RADIUS. - **Authenticity, for the exchange.** The same secret keys the check that lets a network access server satisfy itself that a reply came from the server it asked, and a separate attribute exists to authenticate a request. These are integrity mechanisms; they make tampering detectable, they do not make anything secret. Everything else in an `Access-Request` is plain: the **`User-Name`** identifying the account, the **`NAS-IP-Address`** identifying the device, and on the way back the authorization attributes such as **`Filter-Id`** or **`Session-Timeout`**. An observer on the path reads who is logging in, from which device, and what they were granted. Only the password itself is hidden. ## What TACACS+ masks, and what it does not TACACS+ takes the opposite approach to scope. The **12-byte header** — carrying the version, the packet type, `seq_no`, the flags byte, `session_id` and the body `length` — is always in the clear, because a receiver must read it to know what follows. Everything after it is combined with a pad derived from the shared secret and the header's own fields, so the account name, any prompt text, and the argument-value pairs describing a command are all masked together. What survives in the clear is still meaningful: - that this is TACACS+ on TCP port 49, and which of the three packet families this is; - the `session_id`, so packets can be grouped into exchanges; - `seq_no`, so an observer can count the round trips a login took; - the body `length`, which leaks the size of what was sent. That is enough for traffic analysis — how many exchanges a login needed, how many commands an operator ran and when — without reading one byte of the body. ## Side by side | | RADIUS (classic) | TACACS+ (classic) | |---|---|---| | Scope of hiding | one attribute, `User-Password` | the whole body after the header | | User name on the wire | readable | masked | | Authorization attributes | readable | masked | | Header | readable | readable | | The specification's own word | hiding a single attribute | **obfuscation**, explicitly not encryption | | Integrity of the hidden part | separate secret-keyed checks exist | none from the body protection itself | ## Why 'wider' is not 'stronger' The trap in this question is answering it as a security ranking. Two things are true at once. 1. **TACACS+ covers far more of the packet.** If your concern is that a capture reveals which accounts administer which devices and what they typed, TACACS+ genuinely addresses it and RADIUS genuinely does not. 2. **Neither classic mechanism is encryption in the sense a modern reader means.** RFC 8907 is unusually blunt about its own protocol here: the body protection is obfuscation. It gives no tamper-evidence of its own, and it offers no forward secrecy, so a shared secret recovered later opens captures taken earlier. A candidate who says 'TACACS+ encrypts the whole packet so it is the secure one' has stated the scope correctly and the strength wrongly, and an interviewer probing this leaf is usually probing exactly that seam. ## What follows operationally - Both classic transports are normally confined to a management path rather than run across general-purpose networks, precisely because so little is protected and nothing is forward secret. - The remedy on each side is the same idea: put the exchange inside a real record-protection layer. TACACS+ has a TLS 1.3 transport defined for it on a separate well-known port, and RADIUS has TLS and DTLS transports defined against its UDP original. Those change the answer to this question completely, which is why saying *which* transport you mean is part of answering it. - Rotating a shared secret matters more than it looks, because without forward secrecy the value protects the past as well as the present. ## The shape of a good answer Name the scope on each side, name one thing that stays readable on each side, and then supply the correction the interviewer is waiting for: the TACACS+ advantage is breadth of coverage, and the specification itself declines to call it encryption.

  • If a TACACS+ capture is opaque, what can an observer still learn from it?
    Everything in the 12-byte header: that this is TACACS+ on TCP port 49, the packet type, the `session_id`, the sequence numbers and the body length. That supports traffic analysis — how many round trips a login took, how many commands an operator ran, and at what times — without reading any of the masked body.
  • Does RADIUS leave the rest of the packet unprotected against modification as well as against reading?
    Reading and modification are separate questions. Confidentiality covers `User-Password` alone, but the same shared secret keys checks that let each side detect a forged or altered message. Those checks make tampering detectable; they do not make `User-Name` or the returned attributes secret to anyone watching.
  • Why is the account name readable in a RADIUS Access-Request but masked in a TACACS+ packet?
    Because the two specifications define the scope of protection differently, not because either encrypts. RADIUS defines its hiding per-attribute and applies it to `User-Password` only. TACACS+ defines its masking over the entire body after the header, and the account name lives in the body.

RADIUS posts a postcard with one word blacked out — the address, the sender and the message are all still legible. TACACS+ posts the same card inside an opaque sleeve, but a sleeve anyone can slit open and reseal without leaving a mark.

saying these in an interview costs you the question

  • Says TACACS+ encrypts the packet; the specification says obfuscation
  • Thinks the RADIUS shared secret encrypts the whole Access-Request
  • Claims the TACACS+ 12-byte header is masked with the body
  • Assumes hiding the password also hides the account name
  • Treats whole-body masking as proof of tamper detection
  • Believes RADIUS has no integrity mechanism of any kind