Windows Security API Clarification — TokenHasRestrictions ReturnLength of 1

Question

To the Windows Security API team:

We request clarification regarding Advapi32!GetTokenInformation with TOKEN_INFORMATION_CLASS value 21, TokenHasRestrictions.

Microsoft's documentation specifies a DWORD result indicating whether the token has ever been filtered.

Our TEST_ONLY collector observed:

• Information class: 21.
• Allocated buffer: 65,536 bytes.
• Explicitly aligned, zero-initialized native storage.
• Native API return: success.
• ReturnLength: 1 byte.
• Existing validator: requires exactly four bytes.
• Result: rejected as TOKEN_SCALAR_SIZE.

The collector uses the documented HANDLE, DWORD-compatible information class, LPVOID output, DWORD capacity, PDWORD returned length and BOOL return conventions.

We did not admit the result or retain its raw token value.

Please clarify:

1. Is ReturnLength == 1 officially supported for this information class?
2. What minimum output-buffer capacity and alignment are required?
3. Which output bytes are defined after successful completion?
4. Should callers decode a DWORD, byte or another representation?
5. Are unused bytes defined, and is zero-initialization required?
6. Which return lengths are officially supported?
7. Does behavior vary across Windows builds, architectures or WOW64?
8. Does ReturnLength represent the complete class-specific output?
9. If this behavior is unsupported, what diagnostics should callers collect?
10. Is there an officially documented equivalent method for determining whether a token has ever been filtered? If so, what are its semantic limitations?

Please provide an authoritative API-owner statement or documentation reference identifying the supported caller contract and its version applicability.

References:

https://learn.microsoft.com/en-us/windows/win32/api/winnt/ne-winnt-token_information_class

https://learn.microsoft.com/en-us/windows/win32/api/securitybaseapi/nf-securitybaseapi-gettokeninformation

We are not treating community reproductions, unofficial workarounds or native API success alone as authorization to accept one-byte results.

Answer 1

Thank you for the detailed clarification and for distinguishing the published documentation from the maintainer's statement.

Based on the information provided, I understand that the intended output for TokenHasRestrictions is a BOOLEAN at a DWORD-aligned address, and that ReturnLength == 1 is consistent with the described implementation.

For defensive compatibility, using a zero-initialized, DWORD-aligned four-byte buffer and interpreting only the first byte is reasonable. However, I agree that this should not be presented as proof that four bytes are the officially required minimum capacity, or that all Windows builds and architectures are covered by a formal guarantee.

The remaining issue is having the published Microsoft documentation updated to specify the output type, alignment, valid return length, and applicable version guarantees. Until then, implementations should clearly distinguish the maintainer's clarification from the existing published contract.

Thank you for identifying the documentation issue and the appropriate channels for reporting it.

Answer 2

Thank you for the clarification. To avoid overstating the available evidence, I agree that the observed ReturnLength == 1 behavior should be distinguished from the currently published API contract. A DWORD-aligned, zero-initialized four-byte buffer is a conservative compatibility measure, but it should not be presented as proof of the officially required minimum capacity. An authoritative documentation update specifying the output type, alignment, buffer requirements, and supported return length would resolve the remaining ambiguity.

Answer 3

The key issue is the discrepancy between the published documentation and the observed behavior of TokenHasRestrictions.

The documentation currently describes the output as a DWORD, while the reported Microsoft maintainer clarification indicates that the actual output is a BOOLEAN stored at a DWORD-aligned address, with ReturnLength == 1.

For defensive compatibility, callers can allocate a zero-initialized, DWORD-aligned four-byte buffer, but should interpret only the first byte as a BOOLEAN when the successful call reports a return length of one. The remaining bytes should not be interpreted as part of the result.

However, the distinction between observed behavior and a formally documented contract is important. Until the official documentation is corrected, the minimum buffer capacity, behavior across Windows builds and architectures, and guarantees concerning unused bytes remain insufficiently documented.

IsTokenRestricted is not a fully equivalent alternative because it checks for restricting SIDs rather than whether the token has ever been filtered.

The appropriate next step is to request an official documentation correction in the MicrosoftDocs/sdk-api repository and include reproducible test results, Windows build information, architecture, and the observed return length.

Answer 4

Hello @OUTZA Developer ,

Thank you for the detailed write-up and for being clear about what kind of evidence you can accept. Below I've separated what the published Microsoft documentation says from what Microsoft has said outside the documentation, and I've marked the points where no official source exists yet.

1. What the official documentation currently says

• TOKEN_INFORMATION_CLASS (winnt.h) and TOKEN_INFORMATION_CLASS (ntifs.h) both state: "The buffer receives a DWORD value that is nonzero if the token has ever been filtered." The WDK page adds that the class is valid starting with Windows Vista. As of today, neither page has been updated, so the published contract still disagrees with the ReturnLength == 1 you observed.

2. The only public statement from Microsoft on the actual behavior

In microsoft/win32metadata discussion #2308, a Microsoft maintainer replied after internal discussion:

• "…the documentation is wrong and should say that it returns BOOLEAN but that the BOOLEAN pointer must be DWORD-aligned."
• He confirmed that with a DWORD-aligned buffer, a successful call reporting ReturnLength == 1, with only the first (BOOLEAN) byte valid, is the expected behavior.
• "I expect this is going to be consistent across versions… Any deviation is going to be a bug in the docs, not in the implementation."

This is a public statement from a Microsoft maintainer. It is not published reference documentation, and the version statement is phrased as an expectation, not a guarantee.

3. Answers to your questions, with the source for each

1. Is ReturnLength == 1 supported? The published docs don't say so. The maintainer statement above confirms it as the intended behavior and says the docs are what's wrong.
2. Minimum capacity and alignment:
   • Alignment is documented: NtQueryInformationToken and ZwQueryInformationToken state "All structures must be aligned on a 32-bit boundary," and the maintainer also says the pointer must be DWORD-aligned.
   • Minimum capacity is not documented for this class. GetTokenInformation defines ReturnLength as the number of bytes needed and says the call fails if that exceeds TokenInformationLength. That suggests one byte is enough, but it is an inference, not a stated rule. Until the docs are corrected, I'd suggest keeping a 4-byte, DWORD-aligned buffer as a conservative choice.
3. Which bytes are defined? No published documentation says. Per the maintainer, only byte 0 holds the value.
4. DWORD or byte? The docs say DWORD. The maintainer says BOOLEAN. In Windows, BOOLEAN is defined as typedef BYTE BOOLEAN; (Windows Data Types).
5. Unused bytes and zero-initialization: I couldn't find any official source that addresses either point.
6. Officially supported return lengths: Only the generic definition of ReturnLength exists. Nothing specific to this class is published.
7. Differences across builds, architectures or WOW64: The docs only say the class is valid from Windows Vista onward. The maintainer expects the behavior to be consistent, but no per-build, architecture or WOW64 guarantee has been published.
8. Does ReturnLength cover the complete output? According to the native API docs: ReturnLength receives "the actual length, in bytes, of the information returned in the TokenInformation buffer" (NtQueryInformationToken).
9. Diagnostics for unsupported behavior: Microsoft has not published any guidance on this.
10. Documented equivalent API: The only related documented API is IsTokenRestricted, and it is not equivalent. Its Remarks say it "checks only for the list of restricting SIDs" and returns FALSE "even though the token was created by a call to CreateRestrictedToken." A token filtered only by deny-only SIDs or deleted privileges (see CreateRestrictedToken) would therefore not be detected.

4. Getting an authoritative, versioned contract

Questions 5 and 9, and a formal guarantee for question 7, are not answered by any official source today. When I checked, I also couldn't find an open documentation issue for TokenHasRestrictions. To get the published contract corrected and versioned, I'd suggest:

• Filing a documentation issue at MicrosoftDocs/sdk-api, which the maintainer also recommended, and referencing discussion #2308.
• Sending feedback to the Windows team through the Feedback Hub app (Windows + F): select Report a problem, describe your observed results, Windows build and architecture, and link the two TOKEN_INFORMATION_CLASS pages and discussion #2308, attach any supporting files, then choose the Developer Platform > API Feedback category and submit.

I hope this helps. If you found my response helpful or informative, I would greatly appreciate it if you could follow this guide so others can find it.

Thank you.

Answer 5

TokenHasRestrictions should be decoded as a one-byte BOOLEAN at a DWORD-aligned address when a successful call returns ReturnLength == 1; allocate four zero-initialized bytes defensively, but do not treat four-byte capacity as an established minimum requirement.

Supported interpretation

Microsoft-maintainer guidance, following internal discussion, states that the current documentation is incorrect: the payload is a BOOLEAN, its pointer must be DWORD-aligned, and the observed ReturnLength == 1 behavior should be documented rather than treated as an implementation defect.^1^

For the reported successful call:

• Representation: one-byte BOOLEAN.
• Meaning: zero means false; nonzero means the token has been filtered.
• ReturnLength: 1 describes the complete class-specific BOOLEAN result.
• Defined output: consume only byte 0.
• Bytes 1–3: they are not part of the returned value and must not be decoded as a DWORD.
• Alignment: the output pointer must be DWORD-aligned.
• Minimum capacity: the clarification does not explicitly establish whether the formal minimum is one accessible byte at a DWORD-aligned address or four accessible bytes.
• Recommended capacity: use an aligned four-byte object while the published header documentation still describes a DWORD. This is a conservative compatibility measure, not a confirmed minimum-capacity rule.
• Initialization: zero-initialization is not stated as an API prerequisite. It is advisable defensively so that accidental DWORD decoding cannot incorporate indeterminate trailing bytes.

The current Win32 and WDK pages still say that the buffer receives a DWORD whose nonzero value means the token has ever been filtered.^2^^3^ Those pages therefore remain inconsistent with the public maintainer clarification.

A defensive C++ implementation can accept the corrected result without relying on trailing bytes:

alignas(DWORD) std::byte storage[sizeof(DWORD)]{}; // defensive capacity
DWORD returned = 0;

if (!GetTokenInformation(token, TokenHasRestrictions,
                         storage, sizeof(storage), &returned)) {
    DWORD error = GetLastError();
    // Report error; do not consume storage.
}

if (returned != sizeof(BOOLEAN)) {
    // Unexpected contract result; record diagnostics and reject.
}

const BOOLEAN value = std::to_integer<BOOLEAN>(storage[0]);
const bool hasEverBeenFiltered = (value != FALSE);

The four-byte array preserves DWORD alignment and compatibility with the still-uncorrected DWORD documentation; it is not evidence that four-byte capacity is mandatory.

Version, architecture, and WOW64 scope

The WDK enumeration lists TokenHasRestrictions as valid starting with Windows Vista.^3^ The maintainer expected the one-byte behavior to be consistent across versions, but no published build, architecture, ARM64, or WOW64 test matrix was provided.^1^

Consequently:

• Do not claim a formally documented per-build guarantee beyond the stated Windows Vista applicability.
• Keep the scalar-size validator class-specific rather than globally accepting one-byte results for other token information classes.
• Treat any successful length other than sizeof(BOOLEAN) as unexpected and collect diagnostics rather than guessing its representation.

GetTokenInformation generally defines ReturnLength as the bytes needed for the requested information and requires TOKEN_QUERY for this class.^4^

Alternative API is not semantically equivalent

IsTokenRestricted is documented, but it answers a narrower question: whether the token currently contains a list of restricting SIDs. It returns FALSE when no such list exists—even if CreateRestrictedToken filtered the token by disabling SIDs or deleting privileges.^5^

Therefore, it cannot replace the “has ever been filtered” predicate unless the application only needs to detect restricting SIDs.

Diagnostics for unexpected results

For a successful result other than length 1, retain:

• Exact Windows edition, build, revision, architecture, and WOW64 status.
• Process bitness and compiler/SDK versions.
• advapi32.dll and KernelBase.dll file versions.
• Token type and whether it is primary or impersonation.
• Requested capacity, pointer address modulo alignof(DWORD), returned length, success value, and changed-byte mask.
• A minimal native C/C++ reproduction using TOKEN_QUERY.
• For failure only, the immediate GetLastError() value; last-error after success is not meaningful under this API contract.

The win32metadata maintainer recommended filing a documentation issue to track correction of the published contract.^1^

---

References

1. TokenHasRestrictions: documented DWORD vs observed one-byte output - GitHub
2. TOKEN_INFORMATION_CLASS enumeration (winnt.h)
3. TOKEN_INFORMATION_CLASS enumeration (ntifs.h)
4. GetTokenInformation function (securitybaseapi.h)
5. IsTokenRestricted function (securitybaseapi.h)