whitemagic/WhiteMagic/Native/NativeEnums.cs

namespace WhiteMagic.Native;

/// <summary>
/// Access rights that open a process object.
/// </summary>
[Flags]
public enum ProcessAccess : uint
{
    /// <summary>The right to terminate the process with TerminateProcess.</summary>
    Terminate = 0x0001,
    /// <summary>The right to create a thread in the process.</summary>
    CreateThread = 0x0002,
    /// <summary>The right to operate on the address space of the process.</summary>
    VmOperation = 0x0008,
    /// <summary>The right to read memory with ReadProcessMemory.</summary>
    VmRead = 0x0010,
    /// <summary>The right to write memory with WriteProcessMemory.</summary>
    VmWrite = 0x0020,
    /// <summary>The right to duplicate a handle with DuplicateHandle.</summary>
    DupHandle = 0x0040,
    /// <summary>The right to set information about the process.</summary>
    SetInformation = 0x0200,
    /// <summary>The right to read information about the process, such as the exit code.</summary>
    QueryInformation = 0x0400,
    /// <summary>The right to suspend or resume the process.</summary>
    SuspendResume = 0x0800,
    /// <summary>The right to read a limited set of information about the process.</summary>
    QueryLimitedInformation = 0x1000,
    /// <summary>The right to use the process object for synchronization.</summary>
    Synchronize = 0x00100000,

    /// <summary>All access rights for a process object.</summary>
    AllAccess = 0x001F0000 | Synchronize | 0xFFFF,
}

/// <summary>
/// Values that control how VirtualAllocEx allocates memory.
/// </summary>
[Flags]
public enum MemoryAllocationType : uint
{
    /// <summary>Commit physical storage for the reserved pages. The pages start as zero.</summary>
    Commit = 0x00001000,
    /// <summary>Reserve a range of address space without physical storage.</summary>
    Reserve = 0x00002000,
    /// <summary>Reset the data in the range to indicate that it is no longer of interest.</summary>
    Reset = 0x00080000,
    /// <summary>Allocate memory at the highest possible address.</summary>
    TopDown = 0x00100000,
}

/// <summary>
/// Values that protect a block of memory.
/// </summary>
[Flags]
public enum MemoryProtectionType : uint
{
    /// <summary>No access to the committed pages.</summary>
    NoAccess = 0x01,
    /// <summary>Read access to the committed pages.</summary>
    ReadOnly = 0x02,
    /// <summary>Read and write access to the committed pages.</summary>
    ReadWrite = 0x04,
    /// <summary>Copy-on-write access to the committed pages.</summary>
    WriteCopy = 0x08,
    /// <summary>Execute access to the committed pages.</summary>
    Execute = 0x10,
    /// <summary>Execute and read access to the committed pages.</summary>
    ExecuteRead = 0x20,
    /// <summary>Execute, read, and write access to the committed pages.</summary>
    ExecuteReadWrite = 0x40,
    /// <summary>Execute and copy-on-write access to the committed pages.</summary>
    ExecuteWriteCopy = 0x80,
    /// <summary>The pages in the range become guard pages.</summary>
    Guard = 0x100,
    /// <summary>The system does not cache the committed pages.</summary>
    NoCache = 0x200,
    /// <summary>The system uses write-combined access for the pages.</summary>
    WriteCombine = 0x400,
}

/// <summary>
/// Values that control how VirtualFreeEx frees memory.
/// </summary>
[Flags]
public enum MemoryFreeType : uint
{
    /// <summary>Decommit the committed pages. The address range stays reserved.</summary>
    Decommit = 0x4000,
    /// <summary>Release the range of pages. The size must be zero.</summary>
    Release = 0x8000,
}

/// <summary>
/// Values that set the initial state of a new thread.
/// </summary>
[Flags]
public enum ThreadCreationFlags : uint
{
    /// <summary>The thread runs immediately after creation.</summary>
    RunImmediately = 0,
    /// <summary>The thread starts in a suspended state. Call ResumeThread to start it.</summary>
    CreateSuspended = 0x00000004,
    /// <summary>The stack-size parameter sets the reserve size of the stack.</summary>
    StackSizeParamIsAReservation = 0x00010000,
}

/// <summary>
/// Flags that select the registers that the thread-context functions read or write.
/// There are separate constants for 32-bit (x86/WOW64) and 64-bit (AMD64) contexts.
/// </summary>
public static class ContextFlags
{
    /// <summary>Architecture identifier for x86 contexts.</summary>
    public const uint X86 = 0x00010000;
    /// <summary>Architecture identifier for AMD64 contexts.</summary>
    public const uint Amd64 = 0x00100000;

    /// <summary>x86: SS:SP, CS:IP, FLAGS, and BP.</summary>
    public const uint X86Control = X86 | 0x01;
    /// <summary>x86: AX, BX, CX, DX, SI, and DI.</summary>
    public const uint X86Integer = X86 | 0x02;
    /// <summary>x86: DS, ES, FS, and GS.</summary>
    public const uint X86Segments = X86 | 0x04;
    /// <summary>x86: control, integer, and segment registers.</summary>
    public const uint X86Full = X86Control | X86Integer | X86Segments;

    /// <summary>AMD64: SegSs, Rsp, SegCs, Rip, and EFlags.</summary>
    public const uint Amd64Control = Amd64 | 0x01;
    /// <summary>AMD64: Rax, Rcx, Rdx, Rbx, Rbp, Rsi, Rdi, and R8 to R15.</summary>
    public const uint Amd64Integer = Amd64 | 0x02;
    /// <summary>AMD64: SegDs, SegEs, SegFs, and SegGs.</summary>
    public const uint Amd64Segments = Amd64 | 0x04;
    /// <summary>AMD64: control, integer, and segment registers.</summary>
    public const uint Amd64Full = Amd64Control | Amd64Integer | Amd64Segments;
}