TOKEN_ACCESS_INFORMATION

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct LUID
{
    public uint LowPart;
    public int HighPart;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct TOKEN_MANDATORY_POLICY
{
    public uint Policy;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct TOKEN_ACCESS_INFORMATION
{
    public IntPtr SidHash;
    public IntPtr RestrictedSidHash;
    public IntPtr Privileges;
    public LUID AuthenticationId;
    public int TokenType;
    public int ImpersonationLevel;
    public TOKEN_MANDATORY_POLICY MandatoryPolicy;
    public uint Flags;
    public uint AppContainerNumber;
    public IntPtr PackageSid;
    public IntPtr CapabilitiesHash;
    public IntPtr TrustLevelSid;
    public IntPtr SecurityAttributes;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure LUID
    Public LowPart As UInteger
    Public HighPart As Integer
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure TOKEN_MANDATORY_POLICY
    Public Policy As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure TOKEN_ACCESS_INFORMATION
    Public SidHash As IntPtr
    Public RestrictedSidHash As IntPtr
    Public Privileges As IntPtr
    Public AuthenticationId As LUID
    Public TokenType As Integer
    Public ImpersonationLevel As Integer
    Public MandatoryPolicy As TOKEN_MANDATORY_POLICY
    Public Flags As UInteger
    Public AppContainerNumber As UInteger
    Public PackageSid As IntPtr
    Public CapabilitiesHash As IntPtr
    Public TrustLevelSid As IntPtr
    Public SecurityAttributes As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class LUID(ctypes.Structure):
    _fields_ = [
        ("LowPart", wintypes.DWORD),
        ("HighPart", ctypes.c_int),
    ]

class TOKEN_MANDATORY_POLICY(ctypes.Structure):
    _fields_ = [
        ("Policy", wintypes.DWORD),
    ]

class TOKEN_ACCESS_INFORMATION(ctypes.Structure):
    _fields_ = [
        ("SidHash", ctypes.c_void_p),
        ("RestrictedSidHash", ctypes.c_void_p),
        ("Privileges", ctypes.c_void_p),
        ("AuthenticationId", LUID),
        ("TokenType", ctypes.c_int),
        ("ImpersonationLevel", ctypes.c_int),
        ("MandatoryPolicy", TOKEN_MANDATORY_POLICY),
        ("Flags", wintypes.DWORD),
        ("AppContainerNumber", wintypes.DWORD),
        ("PackageSid", ctypes.c_void_p),
        ("CapabilitiesHash", ctypes.c_void_p),
        ("TrustLevelSid", ctypes.c_void_p),
        ("SecurityAttributes", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct LUID {
    pub LowPart: u32,
    pub HighPart: i32,
}

#[repr(C)]
pub struct TOKEN_MANDATORY_POLICY {
    pub Policy: u32,
}

#[repr(C)]
pub struct TOKEN_ACCESS_INFORMATION {
    pub SidHash: *mut core::ffi::c_void,
    pub RestrictedSidHash: *mut core::ffi::c_void,
    pub Privileges: *mut core::ffi::c_void,
    pub AuthenticationId: LUID,
    pub TokenType: i32,
    pub ImpersonationLevel: i32,
    pub MandatoryPolicy: TOKEN_MANDATORY_POLICY,
    pub Flags: u32,
    pub AppContainerNumber: u32,
    pub PackageSid: *mut core::ffi::c_void,
    pub CapabilitiesHash: *mut core::ffi::c_void,
    pub TrustLevelSid: *mut core::ffi::c_void,
    pub SecurityAttributes: *mut core::ffi::c_void,
}

import "golang.org/x/sys/windows"

type LUID struct {
	LowPart uint32
	HighPart int32
}

type TOKEN_MANDATORY_POLICY struct {
	Policy uint32
}

type TOKEN_ACCESS_INFORMATION struct {
	SidHash uintptr
	RestrictedSidHash uintptr
	Privileges uintptr
	AuthenticationId LUID
	TokenType int32
	ImpersonationLevel int32
	MandatoryPolicy TOKEN_MANDATORY_POLICY
	Flags uint32
	AppContainerNumber uint32
	PackageSid uintptr
	CapabilitiesHash uintptr
	TrustLevelSid uintptr
	SecurityAttributes uintptr
}

type
  LUID = record
    LowPart: DWORD;
    HighPart: Integer;
  end;

  TOKEN_MANDATORY_POLICY = record
    Policy: DWORD;
  end;

  TOKEN_ACCESS_INFORMATION = record
    SidHash: Pointer;
    RestrictedSidHash: Pointer;
    Privileges: Pointer;
    AuthenticationId: LUID;
    TokenType: Integer;
    ImpersonationLevel: Integer;
    MandatoryPolicy: TOKEN_MANDATORY_POLICY;
    Flags: DWORD;
    AppContainerNumber: DWORD;
    PackageSid: Pointer;
    CapabilitiesHash: Pointer;
    TrustLevelSid: Pointer;
    SecurityAttributes: Pointer;
  end;

const LUID = extern struct {
    LowPart: u32,
    HighPart: i32,
};

const TOKEN_MANDATORY_POLICY = extern struct {
    Policy: u32,
};

const TOKEN_ACCESS_INFORMATION = extern struct {
    SidHash: ?*anyopaque,
    RestrictedSidHash: ?*anyopaque,
    Privileges: ?*anyopaque,
    AuthenticationId: LUID,
    TokenType: i32,
    ImpersonationLevel: i32,
    MandatoryPolicy: TOKEN_MANDATORY_POLICY,
    Flags: u32,
    AppContainerNumber: u32,
    PackageSid: ?*anyopaque,
    CapabilitiesHash: ?*anyopaque,
    TrustLevelSid: ?*anyopaque,
    SecurityAttributes: ?*anyopaque,
};

type
  LUID {.bycopy.} = object
    LowPart: uint32
    HighPart: int32

  TOKEN_MANDATORY_POLICY {.bycopy.} = object
    Policy: uint32

  TOKEN_ACCESS_INFORMATION {.bycopy.} = object
    SidHash: pointer
    RestrictedSidHash: pointer
    Privileges: pointer
    AuthenticationId: LUID
    TokenType: int32
    ImpersonationLevel: int32
    MandatoryPolicy: TOKEN_MANDATORY_POLICY
    Flags: uint32
    AppContainerNumber: uint32
    PackageSid: pointer
    CapabilitiesHash: pointer
    TrustLevelSid: pointer
    SecurityAttributes: pointer

struct LUID
{
    uint LowPart;
    int HighPart;
}

struct TOKEN_MANDATORY_POLICY
{
    uint Policy;
}

struct TOKEN_ACCESS_INFORMATION
{
    void* SidHash;
    void* RestrictedSidHash;
    void* Privileges;
    LUID AuthenticationId;
    int TokenType;
    int ImpersonationLevel;
    TOKEN_MANDATORY_POLICY MandatoryPolicy;
    uint Flags;
    uint AppContainerNumber;
    void* PackageSid;
    void* CapabilitiesHash;
    void* TrustLevelSid;
    void* SecurityAttributes;
}