/// <summary>
/// Generic call to Win32.GetTokenInformation. The returned object contains the
/// token information in unmanaged heap (UnmanagedHeapAlloc).
/// It must be disposed by the caller.
/// </summary>
/// <param name="TokenInformationClass">The type of info to retrieve</param>
/// <returns>The ptr to the token information in unmanaged memory</returns>
private UnmanagedHeapAlloc GetTokenInformation(TokenInformationClass TokenInformationClass)
{
DWORD cbLength;
BOOL rc = Win32.GetTokenInformation(_handle, TokenInformationClass, IntPtr.Zero, 0, out cbLength);
switch (Marshal.GetLastWin32Error())
{
case Win32.SUCCESS:
throw new ArgumentException("Unexpected error code returned by GetTokenInformation");
case Win32.ERROR_BAD_LENGTH:
// Special case for TokenSessionId. Win32 doesn't want to return
// us the size of a DWORD.
cbLength = (DWORD)Marshal.SizeOf(typeof(DWORD));
goto case Win32.ERROR_INSUFFICIENT_BUFFER;
case Win32.ERROR_INSUFFICIENT_BUFFER:
UnmanagedHeapAlloc res = new UnmanagedHeapAlloc(cbLength);
try
{
rc = Win32.GetTokenInformation(_handle, TokenInformationClass, res.Ptr, res.Size, out cbLength);
Win32.CheckCall(rc);
}
catch
{
res.Dispose();
throw;
}
return(res);
default:
Win32.ThrowLastError();
return(null); // uneeded
}
}
internal static SafeBuffer GetTokenInformation(SafeTokenHandle tokenHandle, TokenInformationClass informationClass)
{
Debug.Assert(tokenHandle != null && !tokenHandle.IsClosed && !tokenHandle.IsInvalid);
// Figure out how much memory we need to hold this token information
int bufferSize;
UnsafeNativeMethods.GetTokenInformation(tokenHandle,
informationClass,
SafeBuffer.InvalidBuffer,
0,
out bufferSize);
// Allocate a buffer and get the token information
SafeBuffer buffer = SafeBuffer.Allocate(bufferSize);
if (!UnsafeNativeMethods.GetTokenInformation(tokenHandle,
informationClass,
buffer,
bufferSize,
out bufferSize))
{
Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
}
return(buffer);
}
// ReSharper disable once TooManyArguments
public static extern bool GetTokenInformation(
IntPtr tokenHandle,
TokenInformationClass tokenInformationClass,
ref TokenElevationType tokenElevationTypeInformation,
int tokenInformationLength,
out int returnLength
);
internal static extern bool GetTokenInformation(
/* _In_ HANDLE */ [In] SafeTokenHandle tokenHandle,
/* _In_ TOKEN_INFORMATION_CLASS */ [In] TokenInformationClass tokenInformationClass,
/* _Out_ LPVOID */ [In][Out] IntPtr tokenInformation,
/* _In_ DWORD */ [In] uint tokenInformationLength,
/* _Out_ PDWORD */ [Out] out uint returnLength
);
private static extern bool GetTokenInformation(
SafeTokenHandle TokenHandle,
TokenInformationClass TokenInformationClass,
IntPtr TokenInformation,
int TokenInformationLength,
out int ReturnLength
);
private T GetTokenInformation <T>(TokenInformationClass tokenInformationClass) where T : struct
{
using (SafeLocalAllocHandle handle = GetTokenInformation(this.m_safeTokenHandle, tokenInformationClass))
{
return(handle.Read <T>(0L));
}
}
private Sid[] GetGroupsInternal(TokenInformationClass infoClass)
{
int retLen = 0;
Win32.GetTokenInformation(this, infoClass, IntPtr.Zero, 0, out retLen);
using (MemoryAlloc data = new MemoryAlloc(retLen))
{
if (!Win32.GetTokenInformation(this, infoClass, data,
data.Size, out retLen))
{
Win32.Throw();
}
int count = data.ReadStruct <TokenGroups>().GroupCount;
Sid[] sids = new Sid[count];
for (int i = 0; i < count; i++)
{
var saa = data.ReadStruct <SidAndAttributes>(TokenGroups.GroupsOffset, i);
sids[i] = new Sid(saa.Sid, saa.Attributes);
}
return(sids);
}
}
public static extern bool GetTokenInformation(
IntPtr hToken,
TokenInformationClass tokenInfoDesire,
IntPtr pTokenInfo, // a pointer to a win32 struct depending on the value in tokenInfoDesire
uint dwTokenInfoLength,
out uint dwTokenResultLength
);
private void SetInformationInt32(TokenInformationClass infoClass, int value)
{
Win32.NtSetInformationToken(
this,
infoClass,
ref value,
sizeof(int)
).ThrowIf();
}
private IntPtr GetInformationIntPtr(TokenInformationClass infoClass)
{
NtStatus status;
IntPtr value = this.GetInformationIntPtr(infoClass, out status);
status.ThrowIf();
return(value);
}
private int GetInformationInt32(TokenInformationClass infoClass)
{
NtStatus status;
int value = this.GetInformationInt32(infoClass, out status);
status.ThrowIf();
return(value);
}
internal unsafe void GetTokenInformation <T>(TokenInformationClass infoClass, out T buff) where T : unmanaged
{
fixed(void *buffP = &buff)
{
bool success = GetTokenInformation(tokenHandle, infoClass, buffP, (uint)sizeof(T), out _);
if (!success)
{
throw new Win32Exception();
}
}
}
private int GetInformationInt32(TokenInformationClass infoClass)
{
int value;
int retLen;
if (!Win32.GetTokenInformation(this, infoClass, out value, sizeof(int), out retLen))
{
Win32.ThrowLastError();
}
return(value);
}
/// <summary>
/// Get a property from the current token
/// </summary>
private T GetTokenInformation <T>(TokenInformationClass tokenInformationClass) where T : struct
{
Debug.Assert(!_safeTokenHandle.IsInvalid && !_safeTokenHandle.IsClosed, "!m_safeTokenHandle.IsInvalid && !m_safeTokenHandle.IsClosed");
using (SafeLocalAllocHandle information = GetTokenInformation(_safeTokenHandle, tokenInformationClass))
{
Debug.Assert(information.ByteLength >= (ulong)Marshal.SizeOf <T>(),
"information.ByteLength >= (ulong)Marshal.SizeOf(typeof(T))");
return(information.Read <T>(0));
}
}
private void SetInformationInt32(TokenInformationClass infoClass, int value)
{
NtStatus status;
if ((status = Win32.NtSetInformationToken(
this,
infoClass,
ref value,
sizeof(int)
)) >= NtStatus.Error)
{
Win32.Throw(status);
}
}
private IntPtr GetInformationIntPtr(TokenInformationClass infoClass)
{
NtStatus status;
IntPtr value;
value = this.GetInformationIntPtr(infoClass, out status);
if (status >= NtStatus.Error)
{
Win32.Throw(status);
}
return(value);
}
private IntPtr GetInformationIntPtr(TokenInformationClass infoClass, out NtStatus status)
{
IntPtr value;
int retLength;
status = Win32.NtQueryInformationToken(
this,
infoClass,
out value,
IntPtr.Size,
out retLength
);
return(value);
}
private int GetInformationInt32(TokenInformationClass infoClass, out NtStatus status)
{
int value;
int retLength;
status = Win32.NtQueryInformationToken(
this,
infoClass,
out value,
sizeof(int),
out retLength
);
return(value);
}
public unsafe SidAndAttributes[] GetGroupsTokenInformation(TokenInformationClass tokenInformationClass)
{
if (tokenInformationClass != TokenInformationClass.TokenGroups &&
tokenInformationClass != TokenInformationClass.TokenRestrictedSids &&
tokenInformationClass != TokenInformationClass.TokenLogonSid &&
tokenInformationClass != TokenInformationClass.TokenCapabilities &&
tokenInformationClass != TokenInformationClass.TokenDeviceGroups &&
tokenInformationClass != TokenInformationClass.TokenRestrictedDeviceGroups)
{
throw new ArgumentException(string.Format("{0} is not a valid Group token information class", tokenInformationClass), "tokenInformationClass");
}
int tokenSize;
if (!NativeMethods.GetTokenInformation(handle, tokenInformationClass, IntPtr.Zero, 0, out tokenSize) &&
Marshal.GetLastWin32Error() != (int)SystemErrorCode.ErrorInsufficientBuffer)
{
ErrorHelper.ThrowCustomWin32Exception();
}
IntPtr tokenInformationPtr = Marshal.AllocHGlobal(tokenSize);
try
{
if (!NativeMethods.GetTokenInformation(handle, tokenInformationClass, tokenInformationPtr, tokenSize, out tokenSize))
{
ErrorHelper.ThrowCustomWin32Exception();
}
var groupStructure = (NativeTokenGroups)Marshal.PtrToStructure(tokenInformationPtr, typeof(NativeTokenGroups));
IntPtr offset = Marshal.OffsetOf(typeof(NativeTokenGroups), "Groups");
var groups = new SidAndAttributes[groupStructure.GroupCount];
long start = new IntPtr(tokenInformationPtr.ToInt64() + offset.ToInt64()).ToInt64();
for (int i = 0; i < groupStructure.GroupCount; i++)
{
var arrayElementPtr = new IntPtr(start + i * sizeof(NativeSidAndAttributes));
var group = (NativeSidAndAttributes)Marshal.PtrToStructure(arrayElementPtr, typeof(NativeSidAndAttributes));
groups[i] = new SidAndAttributes(group.Attributes, group.Sid);
}
return(groups);
}
finally
{
Marshal.FreeHGlobal(tokenInformationPtr);
}
}
private TResult GetTokenInformation <T, TResult>(TokenInformationClass type, Func <IntPtr, T, TResult> func) where T : struct
{
if (!NativeMethods.GetTokenInformation(_token, type, IntPtr.Zero, 0, out var dwLength))
{
var errorCode = Marshal.GetLastWin32Error();
switch (errorCode)
{
case NativeMethods.ERROR_BAD_LENGTH:
// special case for TokenSessionId. Falling through
case NativeMethods.ERROR_INSUFFICIENT_BUFFER:
var handle = Marshal.AllocHGlobal((int)dwLength);
try
{
if (handle == IntPtr.Zero)
{
throw new OutOfMemoryException();
}
if (!NativeMethods.GetTokenInformation(_token, type, handle, dwLength, out dwLength))
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
var s = Marshal.PtrToStructure <T>(handle);
return(func(handle, s));
}
finally
{
if (handle != IntPtr.Zero)
{
Marshal.FreeHGlobal(handle);
}
}
case NativeMethods.ERROR_INVALID_HANDLE:
throw new ArgumentException("Argument_InvalidImpersonationToken");
default:
throw new Win32Exception(errorCode);
}
}
return(default);
static SafeHGlobalHandle GetTokenInformation(IntPtr tokenHandle, TokenInformationClass tokenInformationClass, out uint dwLength)
{
SafeHGlobalHandle safeAllocHandle = SafeHGlobalHandle.InvalidHandle;
dwLength = (uint)Marshal.SizeOf(typeof(uint));
bool result = NativeMethods.GetTokenInformation(tokenHandle,
(uint)tokenInformationClass,
safeAllocHandle,
0,
out dwLength);
int dwErrorCode = Marshal.GetLastWin32Error();
switch (dwErrorCode)
{
case NativeMethods.ERROR_BAD_LENGTH:
// special case for TokenSessionId. Falling through
case NativeMethods.ERROR_INSUFFICIENT_BUFFER:
safeAllocHandle = SafeHGlobalHandle.AllocHGlobal(dwLength);
result = NativeMethods.GetTokenInformation(tokenHandle,
(uint)tokenInformationClass,
safeAllocHandle,
dwLength,
out dwLength);
dwErrorCode = Marshal.GetLastWin32Error();
if (!result)
{
safeAllocHandle.Close();
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new Win32Exception(dwErrorCode));
}
break;
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new Win32Exception(dwErrorCode));
}
return(safeAllocHandle);
}
public static bool GetTokenInformation(IntPtr TokenHandle, TokenInformationClass InfoClass, IntPtr Info, int Size, out int InfoLength, [CallerMemberName] string callerName = "")
{
if (!PInvokeDebugger.LoggingEnabled)
{
return(PInvoke_GetTokenInformation(TokenHandle, InfoClass, Info, Size, out InfoLength));
}
bool returnValue = PInvoke_GetTokenInformation(TokenHandle, InfoClass, Info, Size, out InfoLength);
PInvokeDebugInfo debugInfo = PInvokeDebugInfo.TraceDebugInfo(
ModuleName,
nameof(GetTokenInformation),
callerName,
returnValue,
false,
nameof(TokenHandle), TokenHandle,
nameof(InfoClass), InfoClass,
nameof(Info), Info,
nameof(Size), Size,
nameof(InfoLength), InfoLength
);
PInvokeDebugger.SafeCapture(debugInfo);
return(returnValue);
}
internal static extern bool GetTokenInformation(IntPtr tokenHandle, TokenInformationClass tokenInformationClass, IntPtr tokenInformation, int tokenInformationLength, out int returnLength);
public static extern BOOL GetTokenInformation(
HANDLE TokenHandle,
TokenInformationClass TokenInformationClass,
LPVOID TokenInformation,
DWORD TokenInformationLength,
out DWORD ReturnLength);
public SidAndAttributes[] GetGroupsTokenInformation(TokenInformationClass tokenInformationClass)
{
return _handle.GetGroupsTokenInformation(tokenInformationClass);
}
internal static extern bool SetTokenInformation(
IntPtr hToken,
TokenInformationClass tokenInfoClass,
IntPtr pTokenInfo,
int tokenInfoLength);
public static extern bool GetTokenInformation( SafeTokenHandle tokenHandle, TokenInformationClass tokenInformationClass, IntPtr tokenInformation, int tokenInformationLength, out int returnLength );
private static extern bool GetTokenInformation(IntPtr TokenHandle, TokenInformationClass TokenInformationClass, IntPtr TokenInformation, uint TokenInformationLength, out uint ReturnLength);
public static extern bool GetTokenInformation(IntPtr TokenHandle,
TokenInformationClass TokenInformationClass, out int TokenInformation,
uint TokenInformationLength, out uint ReturnLength);
public static extern int NtSetInformationToken(
SafeKernelObjectHandle TokenHandle,
TokenInformationClass TokenInformationClass,
byte[] TokenInformation,
int TokenInformationLength);
private static extern int GetTokenInformation(IntPtr token, TokenInformationClass infoClass,
ref TOKEN_LINKED_TOKEN buffer, int bufferLength,
out int returnLength);
private T GetTokenInformation <T>(TokenInformationClass type) where T : struct
{
return(GetTokenInformation <T, T>(type, Identity));
T Identity(T arg) => arg;
}
internal static extern bool SetTokenInformation(
IntPtr hToken,
TokenInformationClass tokenInfoClass,
IntPtr pTokenInfo,
int tokenInfoLength);
public static extern bool GetTokenInformation(
/* [in] */ SafeTokenHandle token,
/* [in] */ TokenInformationClass tokenInfoClass,
/* [in] */ IntPtr tokenInformation,
/* [in] */ int tokeInfoLength,
/* [out] */ out int actualSize);
public static extern bool SetTokenInformation(IntPtr tokenHandle, TokenInformationClass tokenInformationClass, uint tokenInformation, uint tokenInformationLength);
public static extern bool GetTokenInformation(IntPtr hToken, TokenInformationClass tokenInfoClass, IntPtr pTokenInfo, Int32 tokenInfoLength,
out Int32 returnLength);
public static extern NtStatus NtQueryInformationToken(
SafeKernelObjectHandle TokenHandle,
TokenInformationClass TokenInformationClass,
SafeBuffer TokenInformation,
int TokenInformationLength,
out int ReturnLength);
/// <summary>
/// Generic call to Win32.GetTokenInformation. The returned object contains the
/// token information in unmanaged heap (UnmanagedHeapAlloc).
/// It must be disposed by the caller.
/// </summary>
/// <param name="TokenInformationClass">The type of info to retrieve</param>
/// <returns>The ptr to the token information in unmanaged memory</returns>
private UnmanagedHeapAlloc GetTokenInformation(TokenInformationClass TokenInformationClass)
{
DWORD cbLength;
BOOL rc = Win32.GetTokenInformation(_handle, TokenInformationClass, IntPtr.Zero, 0, out cbLength);
switch(Marshal.GetLastWin32Error())
{
case Win32.SUCCESS:
throw new ArgumentException("Unexpected error code returned by GetTokenInformation");
case Win32.ERROR_BAD_LENGTH:
// Special case for TokenSessionId. Win32 doesn't want to return
// us the size of a DWORD.
cbLength = (DWORD)Marshal.SizeOf(typeof(DWORD));
goto case Win32.ERROR_INSUFFICIENT_BUFFER;
case Win32.ERROR_INSUFFICIENT_BUFFER:
UnmanagedHeapAlloc res = new UnmanagedHeapAlloc(cbLength);
try
{
rc = Win32.GetTokenInformation(_handle, TokenInformationClass, res.Ptr, res.Size, out cbLength);
Win32.CheckCall(rc);
}
catch
{
res.Dispose();
throw;
}
return res;
default:
Win32.ThrowLastError();
return null; // uneeded
}
}
private TResult GetTokenInformation <T, TResult>(TokenInformationClass type, Func <T, TResult> func) where T : struct
{
return(GetTokenInformation <T, TResult>(type, (_, arg) => func(arg)));
}
public static extern BOOL GetTokenInformation( HANDLE TokenHandle, TokenInformationClass TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength, out DWORD ReturnLength);
public static extern bool GetTokenInformation(
[In] AccessTokenHandle accessTokenHandle,
[In] TokenInformationClass tokenInformationClass,
[Out] IntPtr tokenInformation,
[In] int tokenInformationLength,
[In, Out] ref int returnLength);
public unsafe SidAndAttributes[] GetGroupsTokenInformation(TokenInformationClass tokenInformationClass)
{
if (tokenInformationClass != TokenInformationClass.TokenGroups &&
tokenInformationClass != TokenInformationClass.TokenRestrictedSids &&
tokenInformationClass != TokenInformationClass.TokenLogonSid &&
tokenInformationClass != TokenInformationClass.TokenCapabilities &&
tokenInformationClass != TokenInformationClass.TokenDeviceGroups &&
tokenInformationClass != TokenInformationClass.TokenRestrictedDeviceGroups)
{
throw new ArgumentException(string.Format("{0} is not a valid Group token information class", tokenInformationClass), "tokenInformationClass");
}
int tokenSize;
if (!NativeMethods.GetTokenInformation(handle, tokenInformationClass, IntPtr.Zero, 0, out tokenSize) &&
Marshal.GetLastWin32Error() != (int)SystemErrorCode.ErrorInsufficientBuffer)
{
ErrorHelper.ThrowCustomWin32Exception();
}
IntPtr tokenInformationPtr = Marshal.AllocHGlobal(tokenSize);
try
{
if (!NativeMethods.GetTokenInformation(handle, tokenInformationClass, tokenInformationPtr, tokenSize, out tokenSize))
{
ErrorHelper.ThrowCustomWin32Exception();
}
var groupStructure = (NativeTokenGroups)Marshal.PtrToStructure(tokenInformationPtr, typeof(NativeTokenGroups));
IntPtr offset = Marshal.OffsetOf(typeof(NativeTokenGroups), "Groups");
var groups = new SidAndAttributes[groupStructure.GroupCount];
long start = new IntPtr(tokenInformationPtr.ToInt64() + offset.ToInt64()).ToInt64();
for (int i = 0; i < groupStructure.GroupCount; i++)
{
var arrayElementPtr = new IntPtr(start + i * sizeof(NativeSidAndAttributes));
var group = (NativeSidAndAttributes)Marshal.PtrToStructure(arrayElementPtr, typeof(NativeSidAndAttributes));
groups[i] = new SidAndAttributes(group.Attributes, group.Sid);
}
return groups;
}
finally
{
Marshal.FreeHGlobal(tokenInformationPtr);
}
}
