NtSetInformationProcess.c File Reference

#include "precomp.h"
#include <internal/ps_i.h>

Include dependency graph for NtSetInformationProcess.c:

Go to the source code of this file.

Functions
static void	Test_ProcBasePriorityClass (void)
static void	Test_ProcRaisePriorityClass (void)
static void	Test_ProcForegroundBackgroundClass (void)
static void	Test_ProcessWx86InformationClass (void)
static void	Test_ProcSetAlignmentProbe (void)
	START_TEST (NtSetInformationProcess)

Function Documentation

START_TEST()

START_TEST

(

NtSetInformationProcess

)

Definition at line 301 of file NtSetInformationProcess.c.

{
    Test_ProcForegroundBackgroundClass();
    Test_ProcBasePriorityClass();
    Test_ProcRaisePriorityClass();
    Test_ProcessWx86InformationClass();
    Test_ProcSetAlignmentProbe();
}

Test_ProcBasePriorityClass()

static void Test_ProcBasePriorityClass ( void  )

static

Definition at line 13 of file NtSetInformationProcess.c.

{
    NTSTATUS Status;
 
    /*
     * Assign a priority of HIGH_PRIORITY (see pstypes.h).
     * The function will fail with a status of STATUS_PRIVILEGE_NOT_HELD
     * as the process who executed the caller doesn't have the requested
     * privileges to perform the operation.
    */
    KPRIORITY BasePriority = HIGH_PRIORITY;
 
    /* Everything is NULL */
    Status = NtSetInformationProcess(NULL,
                                     ProcessBasePriority,
                                     NULL,
                                     0);
    ok_hex(Status, STATUS_INFO_LENGTH_MISMATCH);
 
    /* Set the base priority to an invalid process handle */
    Status = NtSetInformationProcess(NULL,
                                     ProcessBasePriority,
                                     &BasePriority,
                                     sizeof(KPRIORITY));
    ok_hex(Status, STATUS_INVALID_HANDLE);
 
    /* Don't input anything to the caller but the length information is valid */
    Status = NtSetInformationProcess(NtCurrentProcess(),
                                     ProcessBasePriority,
                                     NULL,
                                     sizeof(KPRIORITY));
    ok_hex(Status, STATUS_ACCESS_VIOLATION);
 
    /* Give the base priority input to the caller but length is invalid */
    Status = NtSetInformationProcess(NtCurrentProcess(),
                                     ProcessBasePriority,
                                     &BasePriority,
                                     0);
    ok_hex(Status, STATUS_INFO_LENGTH_MISMATCH);
 
    /* The input buffer is misaligned and length information invalid */
    Status = NtSetInformationProcess(NtCurrentProcess(),
                                     ProcessBasePriority,
                                     (PVOID)1,
                                     0);
    ok_hex(Status, STATUS_INFO_LENGTH_MISMATCH);
 
    /* The input buffer is misaligned */
    Status = NtSetInformationProcess(NtCurrentProcess(),
                                     ProcessBasePriority,
                                     (PVOID)1,
                                     sizeof(KPRIORITY));
    ok_hex(Status, STATUS_DATATYPE_MISALIGNMENT);
 
    /* The input buffer is misaligned (try with an alignment of 2) */
    Status = NtSetInformationProcess(NtCurrentProcess(),
                                     ProcessBasePriority,
                                     (PVOID)2,
                                     sizeof(KPRIORITY));
    ok_hex(Status, STATUS_DATATYPE_MISALIGNMENT);
 
    /* Set the base priority but we have lack privileges to do so */
    Status = NtSetInformationProcess(NtCurrentProcess(),
                                     ProcessBasePriority,
                                     &BasePriority,
                                     sizeof(KPRIORITY));
    ok_hex(Status, STATUS_PRIVILEGE_NOT_HELD);
 
    /*
     * Assign a random priority value this time and
     * set the base priority to the current process.
    */
    BasePriority = 8;
    Status = NtSetInformationProcess(NtCurrentProcess(),
                                     ProcessBasePriority,
                                     &BasePriority,
                                     sizeof(KPRIORITY));
    ok_hex(Status, STATUS_SUCCESS);
}

Referenced by START_TEST().

Test_ProcessWx86InformationClass()

static void Test_ProcessWx86InformationClass ( void  )

static

Definition at line 221 of file NtSetInformationProcess.c.

{
    NTSTATUS Status;
    ULONG VdmPower = 1;
 
    /* Everything is NULL */
    Status = NtSetInformationProcess(NULL,
                                     ProcessWx86Information,
                                     NULL,
                                     0);
    ok_hex(Status, STATUS_INFO_LENGTH_MISMATCH);
 
    /* Don't set anything to the process */
    Status = NtSetInformationProcess(NtCurrentProcess(),
                                     ProcessWx86Information,
                                     NULL,
                                     sizeof(VdmPower));
    ok_hex(Status, STATUS_ACCESS_VIOLATION);
 
    /* The buffer is misaligned and information length is wrong */
    Status = NtSetInformationProcess(NtCurrentProcess(),
                                     ProcessWx86Information,
                                     (PVOID)1,
                                     0);
    ok_hex(Status, STATUS_INFO_LENGTH_MISMATCH);
 
    /* The buffer is misaligned */
    Status = NtSetInformationProcess(NtCurrentProcess(),
                                     ProcessWx86Information,
                                     (PVOID)1,
                                     sizeof(VdmPower));
    ok_hex(Status, STATUS_DATATYPE_MISALIGNMENT);
 
    /* The buffer is misaligned -- try with an alignment size of 2 */
    Status = NtSetInformationProcess(NtCurrentProcess(),
                                     ProcessWx86Information,
                                     (PVOID)2,
                                     sizeof(VdmPower));
    ok_hex(Status, STATUS_DATATYPE_MISALIGNMENT);
 
    /* We do not have privileges to set the VDM power */
    Status = NtSetInformationProcess(NtCurrentProcess(),
                                     ProcessWx86Information,
                                     &VdmPower,
                                     sizeof(VdmPower));
    ok_hex(Status, STATUS_PRIVILEGE_NOT_HELD);
}

Referenced by START_TEST().

Test_ProcForegroundBackgroundClass()

static void Test_ProcForegroundBackgroundClass ( void  )

static

Definition at line 154 of file NtSetInformationProcess.c.

{
    NTSTATUS Status;
    PPROCESS_FOREGROUND_BACKGROUND ProcForeground;
 
    ProcForeground = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PROCESS_FOREGROUND_BACKGROUND));
    if (ProcForeground == NULL)
    {
        skip("Failed to allocate memory block from heap for PROCESS_FOREGROUND_BACKGROUND!\n");
        return;
    }
 
    /* As a test, set the foreground of the retrieved current process to FALSE */
    ProcForeground->Foreground = FALSE;
 
    /* Set everything NULL for the caller */
    Status = NtSetInformationProcess(NULL,
                                     ProcessForegroundInformation,
                                     NULL,
                                     0);
    ok_hex(Status, STATUS_INFO_LENGTH_MISMATCH);
 
    /* Give an invalid process handle (but the input buffer and length are correct) */
    Status = NtSetInformationProcess(NULL,
                                     ProcessForegroundInformation,
                                     ProcForeground,
                                     sizeof(PROCESS_FOREGROUND_BACKGROUND));
    ok_hex(Status, STATUS_INVALID_HANDLE);
 
    /* Give a buffer data to the argument input as NULL */
    Status = NtSetInformationProcess(NtCurrentProcess(),
                                     ProcessForegroundInformation,
                                     NULL,
                                     sizeof(PROCESS_FOREGROUND_BACKGROUND));
    ok_hex(Status, STATUS_ACCESS_VIOLATION);
 
    /* Set the information process foreground with an incorrect buffer alignment and zero buffer length */
    Status = NtSetInformationProcess(NtCurrentProcess(),
                                     ProcessForegroundInformation,
                                     (PVOID)1,
                                     0);
    ok_hex(Status, STATUS_INFO_LENGTH_MISMATCH);
 
    /*
     * Set the information process foreground with an incorrect buffer alignment but correct size length.
     * The function will return STATUS_ACCESS_VIOLATION as the alignment probe requirement is not performed
     * in this class.
     */
    Status = NtSetInformationProcess(NtCurrentProcess(),
                                     ProcessForegroundInformation,
                                     (PVOID)1,
                                     sizeof(PROCESS_FOREGROUND_BACKGROUND));
    ok_hex(Status, STATUS_ACCESS_VIOLATION);
 
    /* Set the foreground information to the current given process, we must expect the function should succeed */
    Status = NtSetInformationProcess(NtCurrentProcess(),
                                     ProcessForegroundInformation,
                                     ProcForeground,
                                     sizeof(PROCESS_FOREGROUND_BACKGROUND));
    ok_hex(Status, STATUS_SUCCESS);
 
    /* Clear all the stuff */
    HeapFree(GetProcessHeap(), 0, ProcForeground);
}

Referenced by START_TEST().

Test_ProcRaisePriorityClass()

static void Test_ProcRaisePriorityClass ( void  )

static

Definition at line 95 of file NtSetInformationProcess.c.

{
    NTSTATUS Status;
 
    /* Raise the priority as much as possible */
    ULONG RaisePriority = MAXIMUM_PRIORITY;
 
    /* Everything is NULL */
    Status = NtSetInformationProcess(NULL,
                                     ProcessRaisePriority,
                                     NULL,
                                     0);
    ok_hex(Status, STATUS_INFO_LENGTH_MISMATCH);
 
    /* A invalid handle to process is given */
    Status = NtSetInformationProcess(NULL,
                                     ProcessRaisePriority,
                                     &RaisePriority,
                                     sizeof(ULONG));
    ok_hex(Status, STATUS_INVALID_HANDLE);
 
    /* The input buffer is misaligned and length information invalid */
    Status = NtSetInformationProcess(NtCurrentProcess(),
                                     ProcessRaisePriority,
                                     (PVOID)1,
                                     0);
    ok_hex(Status, STATUS_INFO_LENGTH_MISMATCH);
 
    /* A NULL buffer has been accessed */
    Status = NtSetInformationProcess(NtCurrentProcess(),
                                     ProcessRaisePriority,
                                     NULL,
                                     sizeof(ULONG));
    ok_hex(Status, STATUS_ACCESS_VIOLATION);
 
    /* The input buffer is misaligned */
    Status = NtSetInformationProcess(NtCurrentProcess(),
                                     ProcessRaisePriority,
                                     (PVOID)1,
                                     sizeof(ULONG));
    ok_hex(Status, STATUS_DATATYPE_MISALIGNMENT);
 
    /* The input buffer is misaligned -- try with an alignment size of 2 */
    Status = NtSetInformationProcess(NtCurrentProcess(),
                                     ProcessRaisePriority,
                                     (PVOID)2,
                                     sizeof(ULONG));
    ok_hex(Status, STATUS_DATATYPE_MISALIGNMENT);
 
    /* Raise the priority of the given current process */
    Status = NtSetInformationProcess(NtCurrentProcess(),
                                     ProcessRaisePriority,
                                     &RaisePriority,
                                     sizeof(ULONG));
    ok_hex(Status, STATUS_SUCCESS);
}

Referenced by START_TEST().

Test_ProcSetAlignmentProbe()

static void Test_ProcSetAlignmentProbe ( void  )

static

Definition at line 271 of file NtSetInformationProcess.c.

{
    ULONG InfoClass;
 
    /* Iterate over the process info classes and begin the tests */
    for (InfoClass = 0; InfoClass < _countof(PsProcessInfoClass); InfoClass++)
    {
        /* The buffer is misaligned */
        QuerySetProcessValidator(SET,
                                 InfoClass,
                                 (PVOID)(ULONG_PTR)1,
                                 PsProcessInfoClass[InfoClass].RequiredSizeSET,
                                 STATUS_DATATYPE_MISALIGNMENT);
 
        /* We set an invalid buffer address */
        QuerySetProcessValidator(SET,
                                 InfoClass,
                                 (PVOID)(ULONG_PTR)PsProcessInfoClass[InfoClass].AlignmentSET,
                                 PsProcessInfoClass[InfoClass].RequiredSizeSET,
                                 STATUS_ACCESS_VIOLATION);
 
        /* The information length is wrong */
        QuerySetProcessValidator(SET,
                                 InfoClass,
                                 (PVOID)(ULONG_PTR)PsProcessInfoClass[InfoClass].AlignmentSET,
                                 PsProcessInfoClass[InfoClass].RequiredSizeSET - 1,
                                 STATUS_INFO_LENGTH_MISMATCH);
    }
}

Referenced by START_TEST().