STATUS_OBJECT_TYPE_MISMATCH <= 핸들에 대한 타입이 잘 못 되었을 경우인데 API에서 해줌으로

이 에러가 날 경우는 없습니다.

STATUS_ACCESS_DENIED <= 접근거부에러인데 우리가 만든 핸들을 우리가 접근하므로 이 에러는 발생하지 않습니다.

STATUS_INVALID_HANDLE <= 핸들이 잘 못 된 경우입니다. 이 에러는 소프트웨어 로직상 핸들을 잘 못 넘겼을 경우에 발생하며

현재 우리가 알려고 하는것은 아주 특수한 경우에 발생할 수 있는 에러가 있는지 알기 위함이므로 무시합니다.

따라서 ObReferenceObjectByHandle함수는 핸들을 잘 못 넘기지 않는 이상은 현재로써 에러가 발생하지 않을것이고

핸들을 잘 못 넘기는건 프로그램의 로직상 문제이므로 무시합니다.

그 다음에 호출하는 함수는 KeSetEvent 함수입니다.

이 함수는 WDK에 문서에 보면 이 함수리턴값이 실패값이 들어간다는 말은 나와 있지 않습니다.

그렇다면 좀 더 확실하게 알기 위해서 KeSetEvent 함수 내부를 보아야 합니다.

내부 코드를 보기전에 PKEVENT는 다음과 같이 생겼습니다.

typedef struct _KEVENT {
    DISPATCHER_HEADER Header;
} KEVENT, *PKEVENT, *PRKEVENT;

typedef struct _DISPATCHER_HEADER {
    union {
        struct {
            UCHAR Type;                 // All (accessible via KOBJECT_TYPE)

            union {
                union {                 // Timer
                    UCHAR TimerControlFlags;
                    struct {
                        UCHAR Absolute              : 1;
                        UCHAR Coalescable           : 1;
                        UCHAR KeepShifting          : 1;    // Periodic timer
                        UCHAR EncodedTolerableDelay : 5;    // Periodic timer
                    } DUMMYSTRUCTNAME;
                } DUMMYUNIONNAME;

                UCHAR Abandoned;        // Queue
                BOOLEAN Signalling;     // Gate/Events
            } DUMMYUNIONNAME;

            union {
                union {
                    UCHAR ThreadControlFlags;  // Thread
                    struct {
                        UCHAR CpuThrottled      : 1;
                        UCHAR CycleProfiling    : 1;
                        UCHAR CounterProfiling  : 1;
                        UCHAR Reserved          : 5;
                    } DUMMYSTRUCTNAME;
                } DUMMYUNIONNAME;
                UCHAR Hand;             // Timer
                UCHAR Size;             // All other objects
            } DUMMYUNIONNAME2;

            union {
                union {                 // Timer
                    UCHAR TimerMiscFlags;
                    struct {

#if !defined(_X86_)

                        UCHAR Index             : TIMER_EXPIRED_INDEX_BITS;

#else

                        UCHAR Index             : 1;
                        UCHAR Processor         : TIMER_PROCESSOR_INDEX_BITS;

#endif

                        UCHAR Inserted          : 1;
                        volatile UCHAR Expired  : 1;
                    } DUMMYSTRUCTNAME;
                } DUMMYUNIONNAME;
                union {                 // Thread
                    BOOLEAN DebugActive;
                    struct {
                        BOOLEAN ActiveDR7       : 1;
                        BOOLEAN Instrumented    : 1;
                        BOOLEAN Reserved2       : 4;
                        BOOLEAN UmsScheduled    : 1;
                        BOOLEAN UmsPrimary      : 1;
                    } DUMMYSTRUCTNAME;
                } DUMMYUNIONNAME;
                BOOLEAN DpcActive;      // Mutant
            } DUMMYUNIONNAME3;
        } DUMMYSTRUCTNAME;

        volatile LONG Lock;             // Interlocked
    } DUMMYUNIONNAME;

    LONG SignalState;                   // Object lock
    LIST_ENTRY WaitListHead;            // Object lock
} DISPATCHER_HEADER;

LONG __stdcall KeSetEvent(PRKEVENT Event, KPRIORITY Increment, BOOLEAN Wait)
{
  LONG result; // eax@2
  void *v5; // ebx@6
  int v6; // edi@6
  LONG v7; // edi@13
  signed int v14; // [sp+10h] [bp-8h]@4
  int v15; // [sp+14h] [bp-4h]@6

  _ESI = Event;
  if ( Event->Header.Type & 0x7F )
  {
    v14 = 0;
LABEL_6:
    v5 = v320;
    LOBYTE(v15) = KeRaiseIrqlToDpcLevel();
    v6 = 0;
    while ( 1 )
    {
      _EAX = _ESI;
      __asm { lock bts dword ptr [eax], 7 }
      if ( !_CF )
        break;
      do
      {
        ++v6;
        if ( v6 & HvlLongSpinCountMask || !(HvlEnlightenments & 0x40) )
          __asm { pause }
        else
          HvlNotifyLongSpinWait(v6);
      }
      while ( (char)*(_DWORD *)&_ESI->Header.Type < 0 );
    }
    v7 = _ESI->Header.SignalState;
    _ESI->Header.SignalState = 1;
    if ( !v7 )
    {
      if ( v14 == v7 )
        KiSignalSynchronizationObject(v5, _ESI);
      else
        KiSignalNotificationObject(v5);
    }
    _EAX = -129;
    __asm { lock and [esi], eax }
    KiExitDispatcher(v5, Wait, 1, Increment, v15);
    return v7;
  }
  result = 1;
  if ( Event->Header.SignalState != 1 || Wait )
  {
    v14 = 1;
    goto LABEL_6;
  }
  return result;
}

내부코드를 보면 Evente 객체에 SignalState 객체를 참고하거나 값을 변경할 뿐 에러를 리턴할 만한 부분은 없습니다.

여기까지 왔다면 이제 결론이 나옵니다.

SetEvent 함수를 사용 할 때 잘 못 된 핸들을 넘기지 않는 이상은 해당 리턴값이 FALSE를 리턴하지 않습니다.

따라서 시스템이 특수한 상황 ( 메모리 부족 ) 에 에러가 발생할 소지가 없으므로 SetEvent 함수는 무조건

성공한다고 가정합니다.

( 주의 : 예제코드에 한해서만 그렇다는 것이며 Event핸들은 여러 프로세스에 의해서 공유되는 코드로 작성하게

  된다면 접근거부 에러도 발생 할 수 있습니다. 그러나 이러한 부분은 프로그래머가 작성하게 되는 코드이므로

  마찬가지로 문제가 발생한다면 로직상에 문제이지 시스템에 특수한 상황에서 발생하는 에러는 아닙니다. )