#region Constants

internal const uint ERROR_INSUFFICIENT_BUFFER = 0x8007007A;

internal const uint STARTUP_LOADER_SAFEMODE = 0x10;

internal const uint S_OK = 0x0;

internal const uint S_FALSE = 0x1;

internal const uint ERROR_ACCESS_DENIED = 0x5;

internal const uint ERROR_FILE_NOT_FOUND = 0x80070002;

internal const uint FUSION_E_PRIVATE_ASM_DISALLOWED = 0x80131044; // Tried to find unsigned assembly in GAC

internal const uint RUNTIME_INFO_DONT_SHOW_ERROR_DIALOG = 0x40;

internal const uint FILE_TYPE_CHAR = 0x0002;

internal const Int32 STD_OUTPUT_HANDLE = -11;

internal const Int32 STD_ERROR_HANDLE = -12;

internal const uint ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004;

internal const uint RPC_S_CALLPENDING = 0x80010115;

internal const uint E_ABORT = (uint)0x80004004;

internal const int FILE_ATTRIBUTE_READONLY = 0x00000001;

internal const int FILE_ATTRIBUTE_DIRECTORY = 0x00000010;

internal const int FILE_ATTRIBUTE_REPARSE_POINT = 0x00000400;

/// <summary>

/// Default buffer size to use when dealing with the Windows API.

/// </summary>

internal const int MAX_PATH = 260;

private const string kernel32Dll = "kernel32.dll";

private const string WINDOWS_FILE_SYSTEM_REGISTRY_KEY = @"SYSTEM\CurrentControlSet\Control\FileSystem";

private const string WINDOWS_LONG_PATHS_ENABLED_VALUE_NAME = "LongPathsEnabled";

private const string WINDOWS_SAC_REGISTRY_KEY = @"SYSTEM\CurrentControlSet\Control\CI\Policy";

private const string WINDOWS_SAC_VALUE_NAME = "VerifiedAndReputablePolicyState";

internal static DateTime MinFileDate { get; } = DateTime.FromFileTimeUtc(0);

internal static HandleRef NullHandleRef = new HandleRef(null, IntPtr.Zero);

internal static IntPtr NullIntPtr = new IntPtr(0);

internal static IntPtr InvalidHandle = new IntPtr(-1);

// As defined in winnt.h:

internal const ushort PROCESSOR_ARCHITECTURE_INTEL = 0;

internal const ushort PROCESSOR_ARCHITECTURE_ARM = 5;

internal const ushort PROCESSOR_ARCHITECTURE_IA64 = 6;

internal const ushort PROCESSOR_ARCHITECTURE_AMD64 = 9;

internal const ushort PROCESSOR_ARCHITECTURE_ARM64 = 12;

internal const uint INFINITE = 0xFFFFFFFF;

internal const uint WAIT_ABANDONED_0 = 0x00000080;

internal const uint WAIT_OBJECT_0 = 0x00000000;

internal const uint WAIT_TIMEOUT = 0x00000102;

#endregion

#region Enums

internal enum StreamHandleType

{

StdOut = STD_OUTPUT_HANDLE,

StdErr = STD_ERROR_HANDLE,

};

private enum PROCESSINFOCLASS : int

{

ProcessBasicInformation = 0,

ProcessQuotaLimits,

ProcessIoCounters,

ProcessVmCounters,

ProcessTimes,

ProcessBasePriority,

ProcessRaisePriority,

ProcessDebugPort,

ProcessExceptionPort,

ProcessAccessToken,

ProcessLdtInformation,

ProcessLdtSize,

ProcessDefaultHardErrorMode,

ProcessIoPortHandlers, // Note: this is kernel mode only

ProcessPooledUsageAndLimits,

ProcessWorkingSetWatch,

ProcessUserModeIOPL,

ProcessEnableAlignmentFaultFixup,

ProcessPriorityClass,

ProcessWx86Information,

ProcessHandleCount,

ProcessAffinityMask,

ProcessPriorityBoost,

MaxProcessInfoClass

};

private enum eDesiredAccess : int

{

DELETE = 0x00010000,

READ_CONTROL = 0x00020000,

WRITE_DAC = 0x00040000,

WRITE_OWNER = 0x00080000,

SYNCHRONIZE = 0x00100000,

STANDARD_RIGHTS_ALL = 0x001F0000,

PROCESS_TERMINATE = 0x0001,

PROCESS_CREATE_THREAD = 0x0002,

PROCESS_SET_SESSIONID = 0x0004,

PROCESS_VM_OPERATION = 0x0008,

PROCESS_VM_READ = 0x0010,

PROCESS_VM_WRITE = 0x0020,

PROCESS_DUP_HANDLE = 0x0040,

PROCESS_CREATE_PROCESS = 0x0080,

PROCESS_SET_QUOTA = 0x0100,

PROCESS_SET_INFORMATION = 0x0200,

PROCESS_QUERY_INFORMATION = 0x0400,

PROCESS_ALL_ACCESS = SYNCHRONIZE | 0xFFF

}

#pragma warning disable 0649, 0169

internal enum LOGICAL_PROCESSOR_RELATIONSHIP

{

RelationProcessorCore,

RelationNumaNode,

RelationCache,

RelationProcessorPackage,

RelationGroup,

RelationAll = 0xffff

}

internal struct SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX

{

public LOGICAL_PROCESSOR_RELATIONSHIP Relationship;

public uint Size;

public PROCESSOR_RELATIONSHIP Processor;

}

[StructLayout(LayoutKind.Sequential)]

internal unsafe struct PROCESSOR_RELATIONSHIP

{

public byte Flags;

private byte EfficiencyClass;

private fixed byte Reserved[20];

public ushort GroupCount;

public IntPtr GroupInfo;

}

#pragma warning restore 0169, 0149

/// <summary>

/// Flags for CoWaitForMultipleHandles

/// </summary>

[Flags]

public enum COWAIT_FLAGS : int

{

/// <summary>

/// Exit when a handle is signaled.

/// </summary>

COWAIT_NONE = 0,

/// <summary>

/// Exit when all handles are signaled AND a message is received.

/// </summary>

COWAIT_WAITALL = 0x00000001,

/// <summary>

/// Exit when an RPC call is serviced.

/// </summary>

COWAIT_ALERTABLE = 0x00000002

}

/// <summary>

/// Processor architecture values

/// </summary>

internal enum ProcessorArchitectures

{

// Intel 32 bit

X86,

// AMD64 64 bit

X64,

// Itanium 64

IA64,

// ARM

ARM,

// ARM64

ARM64,

// WebAssembly

WASM,

// S390x

S390X,

// LongAarch64

LOONGARCH64,

// 32-bit ARMv6

ARMV6,

// PowerPC 64-bit (little-endian)

PPC64LE,

// Who knows

Unknown

}

internal enum SymbolicLink

{

File = 0,

Directory = 1,

AllowUnprivilegedCreate = 2,

}

#endregion

#region Structs

/// <summary>

/// Structure that contain information about the system on which we are running

/// </summary>

[StructLayout(LayoutKind.Sequential)]

internal struct SYSTEM_INFO

{

// This is a union of a DWORD and a struct containing 2 WORDs.

internal ushort wProcessorArchitecture;

internal ushort wReserved;

internal uint dwPageSize;

internal IntPtr lpMinimumApplicationAddress;

internal IntPtr lpMaximumApplicationAddress;

internal IntPtr dwActiveProcessorMask;

internal uint dwNumberOfProcessors;

internal uint dwProcessorType;

internal uint dwAllocationGranularity;

internal ushort wProcessorLevel;

internal ushort wProcessorRevision;

}

/// <summary>

/// Wrap the intptr returned by OpenProcess in a safe handle.

/// </summary>

internal class SafeProcessHandle : SafeHandleZeroOrMinusOneIsInvalid

{

// Create a SafeHandle, informing the base class

// that this SafeHandle instance "owns" the handle,

// and therefore SafeHandle should call

// our ReleaseHandle method when the SafeHandle

// is no longer in use

private SafeProcessHandle() : base(true)

{

}

[SupportedOSPlatform("windows")]

protected override bool ReleaseHandle()

{

return CloseHandle(handle);

}

}

/// <summary>

/// Contains information about the current state of both physical and virtual memory, including extended memory

/// </summary>

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]

internal class MemoryStatus

{

/// <summary>

/// Initializes a new instance of the <see cref="MemoryStatus"/> class.

/// </summary>

public MemoryStatus()

{

#if CLR2COMPATIBILITY

_length = (uint)Marshal.SizeOf(typeof(MemoryStatus));

#else

_length = (uint)Marshal.SizeOf<MemoryStatus>();

#endif

}

/// <summary>

/// Size of the structure, in bytes. You must set this member before calling GlobalMemoryStatusEx.

/// </summary>

private uint _length;

/// <summary>

/// Number between 0 and 100 that specifies the approximate percentage of physical

/// memory that is in use (0 indicates no memory use and 100 indicates full memory use).

/// </summary>

public uint MemoryLoad;

/// <summary>

/// Total size of physical memory, in bytes.

/// </summary>

public ulong TotalPhysical;

/// <summary>

/// Size of physical memory available, in bytes.

/// </summary>

public ulong AvailablePhysical;

/// <summary>

/// Size of the committed memory limit, in bytes. This is physical memory plus the

/// size of the page file, minus a small overhead.

/// </summary>

public ulong TotalPageFile;

/// <summary>

/// Size of available memory to commit, in bytes. The limit is ullTotalPageFile.

/// </summary>

public ulong AvailablePageFile;

/// <summary>

/// Total size of the user mode portion of the virtual address space of the calling process, in bytes.

/// </summary>

public ulong TotalVirtual;

/// <summary>

/// Size of unreserved and uncommitted memory in the user mode portion of the virtual

/// address space of the calling process, in bytes.

/// </summary>

public ulong AvailableVirtual;

/// <summary>

/// Size of unreserved and uncommitted memory in the extended portion of the virtual

/// address space of the calling process, in bytes.

/// </summary>

public ulong AvailableExtendedVirtual;

}

[StructLayout(LayoutKind.Sequential)]

private struct PROCESS_BASIC_INFORMATION

{

public uint ExitStatus;

public IntPtr PebBaseAddress;

public UIntPtr AffinityMask;

public int BasePriority;

public UIntPtr UniqueProcessId;

public UIntPtr InheritedFromUniqueProcessId;

public readonly uint Size

{

get

{

unsafe

{

return (uint)sizeof(PROCESS_BASIC_INFORMATION);

}

}

}

};

/// <summary>

/// Contains information about a file or directory; used by GetFileAttributesEx.

/// </summary>

[StructLayout(LayoutKind.Sequential)]

public struct WIN32_FILE_ATTRIBUTE_DATA

{

internal int fileAttributes;

internal uint ftCreationTimeLow;

internal uint ftCreationTimeHigh;

internal uint ftLastAccessTimeLow;

internal uint ftLastAccessTimeHigh;

internal uint ftLastWriteTimeLow;

internal uint ftLastWriteTimeHigh;

internal uint fileSizeHigh;

internal uint fileSizeLow;

}

/// <summary>

/// Contains the security descriptor for an object and specifies whether

/// the handle retrieved by specifying this structure is inheritable.

/// </summary>

[StructLayout(LayoutKind.Sequential)]

internal class SecurityAttributes

{

public SecurityAttributes()

{

#if (CLR2COMPATIBILITY)

_nLength = (uint)Marshal.SizeOf(typeof(SecurityAttributes));

#else

_nLength = (uint)Marshal.SizeOf<SecurityAttributes>();

#endif

}

private uint _nLength;

public IntPtr lpSecurityDescriptor;

public bool bInheritHandle;

}

private class SystemInformationData

{

/// <summary>

/// Architecture as far as the current process is concerned.

/// It's x86 in wow64 (native architecture is x64 in that case).

/// Otherwise it's the same as the native architecture.

/// </summary>

public readonly ProcessorArchitectures ProcessorArchitectureType;

/// <summary>

/// Actual architecture of the system.

/// </summary>

public readonly ProcessorArchitectures ProcessorArchitectureTypeNative;

/// <summary>

/// Convert SYSTEM_INFO architecture values to the internal enum

/// </summary>

/// <param name="arch"></param>

/// <returns></returns>

private static ProcessorArchitectures ConvertSystemArchitecture(ushort arch)

{

return arch switch

{

PROCESSOR_ARCHITECTURE_INTEL => ProcessorArchitectures.X86,

PROCESSOR_ARCHITECTURE_AMD64 => ProcessorArchitectures.X64,

PROCESSOR_ARCHITECTURE_ARM => ProcessorArchitectures.ARM,

PROCESSOR_ARCHITECTURE_IA64 => ProcessorArchitectures.IA64,

PROCESSOR_ARCHITECTURE_ARM64 => ProcessorArchitectures.ARM64,

_ => ProcessorArchitectures.Unknown,

};

}

/// <summary>

/// Read system info values

/// </summary>

public SystemInformationData()

{

ProcessorArchitectureType = ProcessorArchitectures.Unknown;

ProcessorArchitectureTypeNative = ProcessorArchitectures.Unknown;

if (IsWindows)

{

var systemInfo = new SYSTEM_INFO();

GetSystemInfo(ref systemInfo);

ProcessorArchitectureType = ConvertSystemArchitecture(systemInfo.wProcessorArchitecture);

GetNativeSystemInfo(ref systemInfo);

ProcessorArchitectureTypeNative = ConvertSystemArchitecture(systemInfo.wProcessorArchitecture);

}

else

{

ProcessorArchitectures processorArchitecture = ProcessorArchitectures.Unknown;

#if NETCOREAPP || NETSTANDARD1_1_OR_GREATER

// Get the architecture from the runtime.

processorArchitecture = RuntimeInformation.OSArchitecture switch

{

Architecture.Arm => ProcessorArchitectures.ARM,

Architecture.Arm64 => ProcessorArchitectures.ARM64,

Architecture.X64 => ProcessorArchitectures.X64,

Architecture.X86 => ProcessorArchitectures.X86,

#if NET5_0_OR_GREATER

Architecture.Wasm => ProcessorArchitectures.WASM,

#endif

#if NET6_0_OR_GREATER

Architecture.S390x => ProcessorArchitectures.S390X,

#endif

#if NET7_0_OR_GREATER

Architecture.LoongArch64 => ProcessorArchitectures.LOONGARCH64,

Architecture.Armv6 => ProcessorArchitectures.ARMV6,

Architecture.Ppc64le => ProcessorArchitectures.PPC64LE,

#endif

_ => ProcessorArchitectures.Unknown,

};

#endif

ProcessorArchitectureTypeNative = ProcessorArchitectureType = processorArchitecture;

}

}

}

public static int GetLogicalCoreCount()

{

int numberOfCpus = Environment.ProcessorCount;

// .NET on Windows returns a core count limited to the current NUMA node

// https://github.com/dotnet/runtime/issues/29686

// so always double-check it.

if (IsWindows)

{

var result = GetLogicalCoreCountOnWindows();

if (result != -1)

{

numberOfCpus = result;

}

}

return numberOfCpus;

}

/// <summary>

/// Get the exact physical core count on Windows

/// Useful for getting the exact core count in 32 bits processes,

/// as Environment.ProcessorCount has a 32-core limit in that case.

/// https://github.com/dotnet/runtime/blob/221ad5b728f93489655df290c1ea52956ad8f51c/src/libraries/System.Runtime.Extensions/src/System/Environment.Windows.cs#L171-L210

/// </summary>

[SupportedOSPlatform("windows")]

private static unsafe int GetLogicalCoreCountOnWindows()

{

uint len = 0;

const int ERROR_INSUFFICIENT_BUFFER = 122;

if (!GetLogicalProcessorInformationEx(LOGICAL_PROCESSOR_RELATIONSHIP.RelationProcessorCore, IntPtr.Zero, ref len) &&

Marshal.GetLastWin32Error() == ERROR_INSUFFICIENT_BUFFER)

{

// Allocate that much space

var buffer = new byte[len];

fixed (byte* bufferPtr = buffer)

{

// Call GetLogicalProcessorInformationEx with the allocated buffer

if (GetLogicalProcessorInformationEx(LOGICAL_PROCESSOR_RELATIONSHIP.RelationProcessorCore, (IntPtr)bufferPtr, ref len))

{

// Walk each SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX in the buffer, where the Size of each dictates how

// much space it's consuming. For each group relation, count the number of active processors in each of its group infos.

int processorCount = 0;

byte* ptr = bufferPtr;

byte* endPtr = bufferPtr + len;

while (ptr < endPtr)

{

var current = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)ptr;

if (current->Relationship == LOGICAL_PROCESSOR_RELATIONSHIP.RelationProcessorCore)

{

// Flags is 0 if the core has a single logical proc, LTP_PC_SMT if more than one

// for now, assume "more than 1" == 2, as it has historically been for hyperthreading

processorCount += (current->Processor.Flags == 0) ? 1 : 2;

}

ptr += current->Size;

}

return processorCount;

}

}

}

return -1;

}

#endregion

#region Member data

internal static bool HasMaxPath => MaxPath == MAX_PATH;

/// <summary>

/// Gets the max path limit of the current OS.

/// </summary>

internal static int MaxPath

{

get

{

if (!IsMaxPathSet)

{

SetMaxPath();

}

return _maxPath;

}

}

/// <summary>

/// Cached value for MaxPath.

/// </summary>

private static int _maxPath;

private static bool IsMaxPathSet { get; set; }

private static readonly object MaxPathLock = new object();

private static void SetMaxPath()

{

lock (MaxPathLock)

{

if (!IsMaxPathSet)

{

bool isMaxPathRestricted = Traits.Instance.EscapeHatches.DisableLongPaths || IsMaxPathLegacyWindows();

_maxPath = isMaxPathRestricted ? MAX_PATH : int.MaxValue;

IsMaxPathSet = true;

}

}

}

internal enum LongPathsStatus

{

/// <summary>

/// The registry key is set to 0 or does not exist.

/// </summary>

Disabled,

/// <summary>

/// The registry key does not exist.

/// </summary>

Missing,

/// <summary>

/// The registry key is set to 1.

/// </summary>

Enabled,

/// <summary>

/// Not on Windows.

/// </summary>

NotApplicable,

}

internal static LongPathsStatus IsLongPathsEnabled()

{

if (!IsWindows)

{

return LongPathsStatus.NotApplicable;

}

try

{

return IsLongPathsEnabledRegistry();

}

catch

{

return LongPathsStatus.Disabled;

}

}

internal static bool IsMaxPathLegacyWindows()

{

var longPathsStatus = IsLongPathsEnabled();

return longPathsStatus == LongPathsStatus.Disabled || longPathsStatus == LongPathsStatus.Missing;

}

[SupportedOSPlatform("windows")]

private static LongPathsStatus IsLongPathsEnabledRegistry()

{

using (RegistryKey fileSystemKey = Registry.LocalMachine.OpenSubKey(WINDOWS_FILE_SYSTEM_REGISTRY_KEY))

{

object longPathsEnabledValue = fileSystemKey?.GetValue(WINDOWS_LONG_PATHS_ENABLED_VALUE_NAME, -1);

if (fileSystemKey != null && Convert.ToInt32(longPathsEnabledValue) == -1)

{

return LongPathsStatus.Missing;

}

else if (fileSystemKey != null && Convert.ToInt32(longPathsEnabledValue) == 1)

{

return LongPathsStatus.Enabled;

}

else

{

return LongPathsStatus.Disabled;

}

}

}

private static SAC_State? s_sacState;

/// <summary>

/// Get from registry state of the Smart App Control (SAC) on the system.

/// </summary>

/// <returns>State of SAC</returns>

internal static SAC_State GetSACState()

{

s_sacState ??= GetSACStateInternal();

return s_sacState.Value;

}

internal static SAC_State GetSACStateInternal()

{

if (IsWindows)

{

try

{

return GetSACStateRegistry();

}

catch

{

return SAC_State.Missing;

}

}

return SAC_State.NotApplicable;

}

[SupportedOSPlatform("windows")]

private static SAC_State GetSACStateRegistry()

{

SAC_State SACState = SAC_State.Missing;

using (RegistryKey policyKey = Registry.LocalMachine.OpenSubKey(WINDOWS_SAC_REGISTRY_KEY))

{

if (policyKey != null)

{

object sacValue = policyKey.GetValue(WINDOWS_SAC_VALUE_NAME, -1);

SACState = Convert.ToInt32(sacValue) switch

{

0 => SAC_State.Off,

1 => SAC_State.Enforcement,

2 => SAC_State.Evaluation,

_ => SAC_State.Missing,

};

}

}

return SACState;

}

/// <summary>

/// State of Smart App Control (SAC) on the system.

/// </summary>

internal enum SAC_State

{

/// <summary>

/// 1: SAC is on and enforcing.

/// </summary>

Enforcement,

/// <summary>

/// 2: SAC is on and in evaluation mode.

/// </summary>

Evaluation,

/// <summary>

/// 0: SAC is off.

/// </summary>

Off,

/// <summary>

/// The registry key is missing.

/// </summary>

Missing,

/// <summary>

/// Not on Windows.

/// </summary>

NotApplicable

}

/// <summary>

/// Cached value for IsUnixLike (this method is called frequently during evaluation).

/// </summary>

private static readonly bool s_isUnixLike = IsLinux || IsOSX || IsBSD;

/// <summary>

/// Gets a flag indicating if we are running under a Unix-like system (Mac, Linux, etc.)

/// </summary>

internal static bool IsUnixLike

{

get { return s_isUnixLike; }

}

/// <summary>

/// Gets a flag indicating if we are running under Linux

/// </summary>

[SupportedOSPlatformGuard("linux")]

internal static bool IsLinux

{

#if CLR2COMPATIBILITY

get { return false; }

#else

get { return RuntimeInformation.IsOSPlatform(OSPlatform.Linux); }

#endif