വിൻഡോസ് നേറ്റീവ് ആപ്ലിക്കേഷനുകളും അക്രോണിസ് ആക്റ്റീവ് റീസ്റ്റോർ സേവനവും

ഒരു പരാജയത്തിന് ശേഷം കഴിയുന്നത്ര വേഗത്തിൽ ഉപയോക്താവിനെ അവരുടെ മെഷീനിൽ പ്രവർത്തിക്കാൻ അനുവദിക്കുന്നതിനായി ഞങ്ങൾ ഇന്നോപോളിസ് യൂണിവേഴ്സിറ്റിയിലെ ആൺകുട്ടികളുമായി ചേർന്ന് സജീവ പുനഃസ്ഥാപിക്കൽ സാങ്കേതികവിദ്യ വികസിപ്പിച്ചെടുക്കുന്നതിന്റെ കഥ ഇന്ന് ഞങ്ങൾ തുടരുന്നു. നേറ്റീവ് വിൻഡോസ് ആപ്ലിക്കേഷനുകളെക്കുറിച്ച് ഞങ്ങൾ സംസാരിക്കും, അവയുടെ സൃഷ്ടിയുടെയും സമാരംഭത്തിന്റെയും സവിശേഷതകൾ ഉൾപ്പെടെ. കട്ടിന് താഴെ ഞങ്ങളുടെ പ്രോജക്റ്റിനെ കുറിച്ചുള്ള ചെറിയ കാര്യങ്ങളും നേറ്റീവ് ആപ്ലിക്കേഷനുകൾ എങ്ങനെ എഴുതാം എന്നതിനെക്കുറിച്ചുള്ള ഒരു പ്രായോഗിക ഗൈഡും ഉണ്ട്.

മുൻ പോസ്റ്റുകളിൽ അത് എന്താണെന്ന് ഞങ്ങൾ ഇതിനകം സംസാരിച്ചു സജീവമായ വീണ്ടെടുക്കൽ, ഇന്നോപോളിസിൽ നിന്നുള്ള വിദ്യാർത്ഥികൾ എങ്ങനെ വികസിക്കുന്നു സേവനം. ഇന്ന് ഞാൻ നേറ്റീവ് ആപ്ലിക്കേഷനുകളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാൻ ആഗ്രഹിക്കുന്നു, ഞങ്ങളുടെ സജീവ വീണ്ടെടുക്കൽ സേവനത്തെ "അടക്കം" ചെയ്യാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്ന തലത്തിലേക്ക്. എല്ലാം ശരിയാണെങ്കിൽ, ഞങ്ങൾക്ക് ഇനിപ്പറയുന്നവ ചെയ്യാൻ കഴിയും:

• വളരെ നേരത്തെ തന്നെ സേവനം ആരംഭിക്കുക
• വളരെ നേരത്തെ ബാക്കപ്പ് സ്ഥിതി ചെയ്യുന്ന ക്ലൗഡുമായി ബന്ധപ്പെടുക
• സിസ്റ്റം ഏത് മോഡിലാണ് എന്ന് മനസിലാക്കാൻ വളരെ നേരത്തെ തന്നെ - സാധാരണ ബൂട്ട് അല്ലെങ്കിൽ വീണ്ടെടുക്കൽ
• മുൻകൂട്ടി വീണ്ടെടുക്കാൻ വളരെ കുറച്ച് ഫയലുകൾ
• കൂടുതൽ വേഗത്തിൽ ആരംഭിക്കാൻ ഉപയോക്താവിനെ അനുവദിക്കുക.

ഏതായാലും ഒരു നേറ്റീവ് ആപ്പ് എന്താണ്?

ഈ ചോദ്യത്തിന് ഉത്തരം നൽകാൻ, സിസ്റ്റം വിളിക്കുന്ന കോളുകളുടെ ക്രമം നോക്കാം, ഉദാഹരണത്തിന്, അവന്റെ ആപ്ലിക്കേഷനിലെ ഒരു പ്രോഗ്രാമർ ഒരു ഫയൽ സൃഷ്ടിക്കാൻ ശ്രമിക്കുകയാണെങ്കിൽ.

പവൽ യോസിഫോവിച്ച് - വിൻഡോസ് കേർണൽ പ്രോഗ്രാമിംഗ് (2019)

പ്രോഗ്രാമർ ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു ഫയൽ സൃഷ്‌ടിക്കുക, fileapi.h എന്ന തലക്കെട്ട് ഫയലിൽ പ്രഖ്യാപിക്കുകയും Kernel32.dll-ൽ നടപ്പിലാക്കുകയും ചെയ്യുന്നു. എന്നിരുന്നാലും, ഈ ഫംഗ്ഷൻ തന്നെ ഫയൽ സൃഷ്ടിക്കുന്നില്ല, ഇത് ഇൻപുട്ട് ആർഗ്യുമെന്റുകൾ പരിശോധിക്കുകയും ഫംഗ്ഷനെ വിളിക്കുകയും ചെയ്യുന്നു NtCreateFile (പ്രിഫിക്‌സ് Nt ഫംഗ്‌ഷൻ നേറ്റീവ് ആണെന്ന് സൂചിപ്പിക്കുന്നു). ഈ ഫംഗ്‌ഷൻ winternl.h ഹെഡർ ഫയലിൽ പ്രഖ്യാപിക്കുകയും ntdll.dll-ൽ നടപ്പിലാക്കുകയും ചെയ്യുന്നു. അത് ന്യൂക്ലിയർ ബഹിരാകാശത്തേക്ക് കുതിക്കാൻ തയ്യാറെടുക്കുന്നു, അതിനുശേഷം അത് ഒരു ഫയൽ സൃഷ്ടിക്കാൻ ഒരു സിസ്റ്റം കോൾ ചെയ്യുന്നു. ഈ സാഹചര്യത്തിൽ, Kernel32 Ntdll-നുള്ള ഒരു റാപ്പർ മാത്രമാണെന്ന് മാറുന്നു. ഇത് ചെയ്തതിന്റെ ഒരു കാരണം, മൈക്രോസോഫ്റ്റിന് നേറ്റീവ് ലോകത്തിന്റെ പ്രവർത്തനങ്ങൾ മാറ്റാനുള്ള കഴിവുണ്ട്, പക്ഷേ സ്റ്റാൻഡേർഡ് ഇന്റർഫേസുകളിൽ സ്പർശിക്കരുത്. നേറ്റീവ് ഫംഗ്‌ഷനുകൾ നേരിട്ട് വിളിക്കാൻ Microsoft ശുപാർശ ചെയ്യുന്നില്ല, അവയിൽ മിക്കതും ഡോക്യുമെന്റ് ചെയ്യുന്നില്ല. വഴിയിൽ, രേഖപ്പെടുത്താത്ത പ്രവർത്തനങ്ങൾ കണ്ടെത്താനാകും ഇവിടെ.

നേറ്റീവ് ആപ്ലിക്കേഷനുകളുടെ പ്രധാന നേട്ടം, കെർണൽ 32 നേക്കാൾ വളരെ നേരത്തെ തന്നെ ntdll സിസ്റ്റത്തിലേക്ക് ലോഡ് ചെയ്യപ്പെടുന്നു എന്നതാണ്. ഇത് ലോജിക്കൽ ആണ്, കാരണം kernel32 ന് പ്രവർത്തിക്കാൻ ntdll ആവശ്യമാണ്. തൽഫലമായി, നേറ്റീവ് ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കുന്ന ആപ്ലിക്കേഷനുകൾ വളരെ നേരത്തെ തന്നെ പ്രവർത്തിക്കാൻ തുടങ്ങും.

അതിനാൽ, വിൻഡോസ് ബൂട്ടിന്റെ തുടക്കത്തിൽ തന്നെ ആരംഭിക്കാൻ കഴിയുന്ന പ്രോഗ്രാമുകളാണ് വിൻഡോസ് നേറ്റീവ് ആപ്ലിക്കേഷനുകൾ. അവർ ntdll-ൽ നിന്നുള്ള ഫംഗ്‌ഷനുകൾ മാത്രമാണ് ഉപയോഗിക്കുന്നത്. അത്തരമൊരു ആപ്ലിക്കേഷന്റെ ഉദാഹരണം: autochk ആർ നിർവഹിക്കുന്നു chkdisk യൂട്ടിലിറ്റി പ്രധാന സേവനങ്ങൾ ആരംഭിക്കുന്നതിന് മുമ്പ് പിശകുകൾക്കായി ഡിസ്ക് പരിശോധിക്കുന്നതിന്. ഞങ്ങളുടെ സജീവമായ പുനഃസ്ഥാപനം ഞങ്ങൾ ആഗ്രഹിക്കുന്ന ലെവലാണിത്.

നമുക്ക് എന്താണ് വേണ്ടത്?

• ഡി.ഡി.കെ (ഡ്രൈവർ ഡെവലപ്‌മെന്റ് കിറ്റ്), ഇപ്പോൾ WDK 7 (Windows Driver Kit) എന്നും അറിയപ്പെടുന്നു.
• വെർച്വൽ മെഷീൻ (ഉദാഹരണത്തിന്, Windows 7 x64)
• ആവശ്യമില്ല, എന്നാൽ ഡൗൺലോഡ് ചെയ്യാൻ കഴിയുന്ന ഹെഡർ ഫയലുകൾ സഹായിച്ചേക്കാം ഇവിടെ

കോഡിൽ എന്താണ് ഉള്ളത്?

നമുക്ക് കുറച്ച് പരിശീലിക്കാം, ഉദാഹരണത്തിന്, ഒരു ചെറിയ ആപ്ലിക്കേഷൻ എഴുതുക:

1. സ്ക്രീനിൽ ഒരു സന്ദേശം പ്രദർശിപ്പിക്കുന്നു
2. കുറച്ച് മെമ്മറി അനുവദിക്കുന്നു
3. കീബോർഡ് ഇൻപുട്ടിനായി കാത്തിരിക്കുന്നു
4. ഉപയോഗിച്ച മെമ്മറി സ്വതന്ത്രമാക്കുന്നു

നേറ്റീവ് ആപ്ലിക്കേഷനുകളിൽ, എൻട്രി പോയിന്റ് പ്രധാനമോ വിൻമൈനോ അല്ല, മറിച്ച് NtProcessStartup ഫംഗ്‌ഷനാണ്, കാരണം ഞങ്ങൾ യഥാർത്ഥത്തിൽ സിസ്റ്റത്തിൽ പുതിയ പ്രോസസ്സുകൾ നേരിട്ട് സമാരംഭിക്കുന്നു.

സ്ക്രീനിൽ ഒരു സന്ദേശം പ്രദർശിപ്പിച്ചുകൊണ്ട് നമുക്ക് ആരംഭിക്കാം. ഇതിനായി ഞങ്ങൾക്ക് ഒരു നേറ്റീവ് ഫംഗ്ഷൻ ഉണ്ട് NtDisplayString, UNICODE_STRING ഘടനാപരമായ ഒബ്‌ജക്‌റ്റിലേക്കുള്ള ഒരു പോയിന്റർ ഒരു ആർഗ്യുമെന്റായി എടുക്കുന്നു. RtlInitUnicodeString അത് ആരംഭിക്കാൻ ഞങ്ങളെ സഹായിക്കും. തൽഫലമായി, സ്ക്രീനിൽ ടെക്സ്റ്റ് പ്രദർശിപ്പിക്കുന്നതിന് നമുക്ക് ഈ ചെറിയ ഫംഗ്ഷൻ എഴുതാം:

//usage: WriteLn(L"Here is my textn");
void WriteLn(LPWSTR Message)
{
    UNICODE_STRING string;
    RtlInitUnicodeString(&string, Message);
    NtDisplayString(&string);
}

ntdll-ൽ നിന്നുള്ള ഫംഗ്‌ഷനുകൾ മാത്രമേ ഞങ്ങൾക്ക് ലഭ്യമാകൂ, കൂടാതെ മെമ്മറിയിൽ മറ്റ് ലൈബ്രറികളൊന്നും ഇതുവരെ ഇല്ലാത്തതിനാൽ, മെമ്മറി എങ്ങനെ അനുവദിക്കാമെന്നതിൽ ഞങ്ങൾക്ക് തീർച്ചയായും പ്രശ്‌നങ്ങളുണ്ടാകും. പുതിയ ഓപ്പറേറ്റർ ഇതുവരെ നിലവിലില്ല (കാരണം ഇത് വളരെ ഉയർന്ന തലത്തിലുള്ള C++ ലോകത്തിൽ നിന്നാണ് വരുന്നത്), കൂടാതെ malloc ഫംഗ്‌ഷനൊന്നും ഇല്ല (ഇതിന് റൺടൈം C ലൈബ്രറികൾ ആവശ്യമാണ്). തീർച്ചയായും, നിങ്ങൾക്ക് ഒരു സ്റ്റാക്ക് മാത്രമേ ഉപയോഗിക്കാൻ കഴിയൂ. എന്നാൽ നമുക്ക് മെമ്മറി ചലനാത്മകമായി അനുവദിക്കണമെങ്കിൽ, അത് കൂമ്പാരത്തിൽ (അതായത് കൂമ്പാരം) ചെയ്യേണ്ടിവരും. അതുകൊണ്ട് നമുക്ക് നമുക്കായി ഒരു കൂമ്പാരം ഉണ്ടാക്കാം, നമുക്ക് ആവശ്യമുള്ളപ്പോഴെല്ലാം അതിൽ നിന്ന് മെമ്മറി എടുക്കാം.

ഈ ടാസ്ക്കിന് ഫംഗ്ഷൻ അനുയോജ്യമാണ് RtlCreateHeap. അടുത്തതായി, RtlAllocateHeap, RtlFreeHeap എന്നിവ ഉപയോഗിച്ച്, നമുക്ക് ആവശ്യമുള്ളപ്പോൾ മെമ്മറി സ്വതന്ത്രമാക്കും.

PVOID memory = NULL;
PVOID buffer = NULL;
ULONG bufferSize = 42;

// create heap in order to allocate memory later
memory = RtlCreateHeap(
  HEAP_GROWABLE, 
  NULL, 
  1000, 
  0, NULL, NULL
);

// allocate buffer of size bufferSize
buffer = RtlAllocateHeap(
  memory, 
  HEAP_ZERO_MEMORY, 
  bufferSize
);

// free buffer (actually not needed because we destroy heap in next step)
RtlFreeHeap(memory, 0, buffer);

RtlDestroyHeap(memory);

കീബോർഡ് ഇൻപുട്ടിനായി നമുക്ക് കാത്തിരിക്കാം.

// https://docs.microsoft.com/en-us/windows/win32/api/ntddkbd/ns-ntddkbd-keyboard_input_data
typedef struct _KEYBOARD_INPUT_DATA {
  USHORT UnitId;
  USHORT MakeCode;
  USHORT Flags;
  USHORT Reserved;
  ULONG  ExtraInformation;
} KEYBOARD_INPUT_DATA, *PKEYBOARD_INPUT_DATA;

//...

HANDLE hKeyBoard, hEvent;
UNICODE_STRING skull, keyboard;
OBJECT_ATTRIBUTES ObjectAttributes;
IO_STATUS_BLOCK Iosb;
LARGE_INTEGER ByteOffset;
KEYBOARD_INPUT_DATA kbData;

// inialize variables
RtlInitUnicodeString(&keyboard, L"DeviceKeyboardClass0");
InitializeObjectAttributes(&ObjectAttributes, &keyboard, OBJ_CASE_INSENSITIVE, NULL, NULL);

// open keyboard device
NtCreateFile(&hKeyBoard,
			SYNCHRONIZE | GENERIC_READ | FILE_READ_ATTRIBUTES,
			&ObjectAttributes,
			&Iosb,
			NULL,
			FILE_ATTRIBUTE_NORMAL,
			0,
			FILE_OPEN,FILE_DIRECTORY_FILE,
			NULL, 0);

// create event to wait on
InitializeObjectAttributes(&ObjectAttributes, NULL, 0, NULL, NULL);
NtCreateEvent(&hEvent, EVENT_ALL_ACCESS, &ObjectAttributes, 1, 0);

while (TRUE)
{
	NtReadFile(hKeyBoard, hEvent, NULL, NULL, &Iosb, &kbData, sizeof(KEYBOARD_INPUT_DATA), &ByteOffset, NULL);
	NtWaitForSingleObject(hEvent, TRUE, NULL);

	if (kbData.MakeCode == 0x01)    // if ESC pressed
	{
			break;
	}
}

നമുക്ക് വേണ്ടത് ഉപയോഗിക്കുന്നത് മാത്രമാണ് NtReadFile ഒരു തുറന്ന ഉപകരണത്തിൽ, കീബോർഡ് ഞങ്ങൾക്ക് എന്തെങ്കിലും അമർത്തുന്നത് വരെ കാത്തിരിക്കുക. ESC കീ അമർത്തിയാൽ, ഞങ്ങൾ ജോലി തുടരും. ഉപകരണം തുറക്കാൻ, ഞങ്ങൾ NtCreateFile ഫംഗ്‌ഷനിലേക്ക് വിളിക്കേണ്ടതുണ്ട് (ഞങ്ങൾ DeviceKeyboardClass0 തുറക്കേണ്ടതുണ്ട്). ഞങ്ങളും വിളിക്കും NtCreateEventവെയിറ്റ് ഒബ്ജക്റ്റ് ആരംഭിക്കാൻ. കീബോർഡ് ഡാറ്റയെ പ്രതിനിധീകരിക്കുന്ന KEYBOARD_INPUT_DATA ഘടന ഞങ്ങൾ സ്വയം പ്രഖ്യാപിക്കും. ഇത് നമ്മുടെ ജോലി എളുപ്പമാക്കും.

നേറ്റീവ് ആപ്ലിക്കേഷൻ ഒരു ഫംഗ്ഷൻ കോളോടെ അവസാനിക്കുന്നു NtTerminateProcessകാരണം നമ്മൾ നമ്മുടെ സ്വന്തം പ്രക്രിയയെ കൊല്ലുകയാണ്.

ഞങ്ങളുടെ ചെറിയ ആപ്ലിക്കേഷന്റെ എല്ലാ കോഡുകളും:

#include "ntifs.h" // WinDDK7600.16385.1incddk
#include "ntdef.h"

//------------------------------------
// Following function definitions can be found in native development kit
// but I am too lazy to include `em so I declare it here
//------------------------------------

NTSYSAPI
NTSTATUS
NTAPI
NtTerminateProcess(
  IN HANDLE               ProcessHandle OPTIONAL,
  IN NTSTATUS             ExitStatus
);

NTSYSAPI 
NTSTATUS
NTAPI
NtDisplayString(
	IN PUNICODE_STRING String
);

NTSTATUS 
NtWaitForSingleObject(
  IN HANDLE         Handle,
  IN BOOLEAN        Alertable,
  IN PLARGE_INTEGER Timeout
);

NTSYSAPI 
NTSTATUS
NTAPI
NtCreateEvent(
    OUT PHANDLE             EventHandle,
    IN ACCESS_MASK          DesiredAccess,
    IN POBJECT_ATTRIBUTES   ObjectAttributes OPTIONAL,
    IN EVENT_TYPE           EventType,
    IN BOOLEAN              InitialState
);



// https://docs.microsoft.com/en-us/windows/win32/api/ntddkbd/ns-ntddkbd-keyboard_input_data
typedef struct _KEYBOARD_INPUT_DATA {
  USHORT UnitId;
  USHORT MakeCode;
  USHORT Flags;
  USHORT Reserved;
  ULONG  ExtraInformation;
} KEYBOARD_INPUT_DATA, *PKEYBOARD_INPUT_DATA;

//----------------------------------------------------------
// Our code goes here
//----------------------------------------------------------

// usage: WriteLn(L"Hello Native World!n");
void WriteLn(LPWSTR Message)
{
    UNICODE_STRING string;
    RtlInitUnicodeString(&string, Message);
    NtDisplayString(&string);
}

void NtProcessStartup(void* StartupArgument)
{
	// it is important to declare all variables at the beginning
	HANDLE hKeyBoard, hEvent;
	UNICODE_STRING skull, keyboard;
	OBJECT_ATTRIBUTES ObjectAttributes;
	IO_STATUS_BLOCK Iosb;
	LARGE_INTEGER ByteOffset;
	KEYBOARD_INPUT_DATA kbData;
	
	PVOID memory = NULL;
	PVOID buffer = NULL;
	ULONG bufferSize = 42;

	//use it if debugger connected to break
	//DbgBreakPoint();

	WriteLn(L"Hello Native World!n");

	// inialize variables
	RtlInitUnicodeString(&keyboard, L"DeviceKeyboardClass0");
	InitializeObjectAttributes(&ObjectAttributes, &keyboard, OBJ_CASE_INSENSITIVE, NULL, NULL);

	// open keyboard device
	NtCreateFile(&hKeyBoard,
				SYNCHRONIZE | GENERIC_READ | FILE_READ_ATTRIBUTES,
				&ObjectAttributes,
				&Iosb,
				NULL,
				FILE_ATTRIBUTE_NORMAL,
				0,
				FILE_OPEN,FILE_DIRECTORY_FILE,
				NULL, 0);

	// create event to wait on
	InitializeObjectAttributes(&ObjectAttributes, NULL, 0, NULL, NULL);
	NtCreateEvent(&hEvent, EVENT_ALL_ACCESS, &ObjectAttributes, 1, 0);
	
	WriteLn(L"Keyboard readyn");
	
	// create heap in order to allocate memory later
	memory = RtlCreateHeap(
	  HEAP_GROWABLE, 
	  NULL, 
	  1000, 
	  0, NULL, NULL
	);
	
	WriteLn(L"Heap readyn");

	// allocate buffer of size bufferSize
	buffer = RtlAllocateHeap(
	  memory, 
	  HEAP_ZERO_MEMORY, 
	  bufferSize
	);
	
	WriteLn(L"Buffer allocatedn");

	// free buffer (actually not needed because we destroy heap in next step)
	RtlFreeHeap(memory, 0, buffer);

	RtlDestroyHeap(memory);
	
	WriteLn(L"Heap destroyedn");
	
	WriteLn(L"Press ESC to continue...n");

	while (TRUE)
	{
		NtReadFile(hKeyBoard, hEvent, NULL, NULL, &Iosb, &kbData, sizeof(KEYBOARD_INPUT_DATA), &ByteOffset, NULL);
		NtWaitForSingleObject(hEvent, TRUE, NULL);

		if (kbData.MakeCode == 0x01)    // if ESC pressed
		{
				break;
		}
	}

	NtTerminateProcess(NtCurrentProcess(), 0);
}

PS: ഡീബഗ്ഗറിൽ നിർത്താൻ ഞങ്ങളുടെ കോഡിലെ DbgBreakPoint() ഫംഗ്‌ഷൻ എളുപ്പത്തിൽ ഉപയോഗിക്കാം. ശരിയാണ്, കേർണൽ ഡീബഗ്ഗിംഗിനായി നിങ്ങൾ WinDbg ഒരു വെർച്വൽ മെഷീനിലേക്ക് ബന്ധിപ്പിക്കേണ്ടതുണ്ട്. ഇത് എങ്ങനെ ചെയ്യണമെന്നതിനുള്ള നിർദ്ദേശങ്ങൾ കണ്ടെത്താനാകും ഇവിടെ അല്ലെങ്കിൽ ഉപയോഗിക്കുക VirtualKD.

സമാഹരണവും അസംബ്ലിയും

ഒരു നേറ്റീവ് ആപ്ലിക്കേഷൻ നിർമ്മിക്കാനുള്ള ഏറ്റവും എളുപ്പ മാർഗം ഉപയോഗിക്കുക എന്നതാണ് ഡി.ഡി.കെ (ഡ്രൈവർ വികസന കിറ്റ്). പിന്നീടുള്ള പതിപ്പുകൾക്ക് അല്പം വ്യത്യസ്തമായ സമീപനവും വിഷ്വൽ സ്റ്റുഡിയോയുമായി ചേർന്ന് പ്രവർത്തിക്കുന്നതിനാലും ഞങ്ങൾക്ക് പുരാതന ഏഴാമത്തെ പതിപ്പ് ആവശ്യമാണ്. ഞങ്ങൾ DDK ഉപയോഗിക്കുകയാണെങ്കിൽ, ഞങ്ങളുടെ പ്രോജക്റ്റിന് Makefile ഉം ഉറവിടങ്ങളും മാത്രമേ ആവശ്യമുള്ളൂ.

Makefile

!INCLUDE $(NTMAKEENV)makefile.def

ഉറവിടങ്ങൾ:

TARGETNAME			= MyNative
TARGETTYPE			= PROGRAM
UMTYPE				= nt
BUFFER_OVERFLOW_CHECKS 		= 0
MINWIN_SDK_LIB_PATH		= $(SDK_LIB_PATH)
SOURCES 			= source.c

INCLUDES 			= $(DDK_INC_PATH); 
				  C:WinDDK7600.16385.1ndk;

TARGETLIBS 			= $(DDK_LIB_PATH)ntdll.lib	
				  $(DDK_LIB_PATH)nt.lib

USE_NTDLL			= 1

നിങ്ങളുടെ Makefile തികച്ചും സമാനമായിരിക്കും, എന്നാൽ ഉറവിടങ്ങൾ കുറച്ചുകൂടി വിശദമായി നോക്കാം. ഈ ഫയൽ നിങ്ങളുടെ പ്രോഗ്രാമിന്റെ ഉറവിടങ്ങൾ (.c ഫയലുകൾ), ബിൽഡ് ഓപ്ഷനുകൾ, മറ്റ് പാരാമീറ്ററുകൾ എന്നിവ വ്യക്തമാക്കുന്നു.

• TARGETNAME - അവസാനം നിർമ്മിക്കേണ്ട എക്സിക്യൂട്ടബിൾ ഫയലിന്റെ പേര്.
• TARGETTYPE - എക്സിക്യൂട്ടബിൾ ഫയലിന്റെ തരം, അത് ഒരു ഡ്രൈവർ (.sys) ആകാം, തുടർന്ന് ഫീൽഡ് മൂല്യം ഡ്രൈവർ ആയിരിക്കണം, ലൈബ്രറി (.lib) ആണെങ്കിൽ, മൂല്യം ലൈബ്രറി ആണ്. ഞങ്ങളുടെ കാര്യത്തിൽ, ഞങ്ങൾക്ക് ഒരു എക്സിക്യൂട്ടബിൾ ഫയൽ (.exe) ആവശ്യമാണ്, അതിനാൽ ഞങ്ങൾ മൂല്യം PROGRAM-ലേക്ക് സജ്ജമാക്കുന്നു.
• UMTYPE - ഈ ഫീൽഡിനായി സാധ്യമായ മൂല്യങ്ങൾ: ഒരു കൺസോൾ ആപ്ലിക്കേഷനുള്ള കൺസോൾ, വിൻഡോ മോഡിൽ പ്രവർത്തിക്കുന്നതിനുള്ള വിൻഡോകൾ. എന്നാൽ ഒരു നേറ്റീവ് ആപ്ലിക്കേഷൻ ലഭിക്കുന്നതിന് നമുക്ക് nt വ്യക്തമാക്കേണ്ടതുണ്ട്.
• BUFFER_OVERFLOW_CHECKS - ബഫർ ഓവർഫ്ലോയ്‌ക്കായി സ്റ്റാക്ക് പരിശോധിക്കുന്നു, നിർഭാഗ്യവശാൽ ഞങ്ങളുടെ കാര്യമല്ല, ഞങ്ങൾ അത് ഓഫാക്കുന്നു.
• MINWIN_SDK_LIB_PATH – ഈ മൂല്യം SDK_LIB_PATH വേരിയബിളിനെ സൂചിപ്പിക്കുന്നു, ഡിഡികെയിൽ നിന്ന് ഞങ്ങൾ ചെക്ക്ഡ് ബിൽഡ് പ്രവർത്തിപ്പിക്കുമ്പോൾ, ഡിക്ലയർ ചെയ്ത അത്തരമൊരു സിസ്റ്റം വേരിയബിൾ നിങ്ങളുടെ പക്കലില്ലെന്ന് വിഷമിക്കേണ്ട, ഈ വേരിയബിൾ പ്രഖ്യാപിക്കപ്പെടുകയും ആവശ്യമായ ലൈബ്രറികളിലേക്ക് പോയിന്റ് ചെയ്യുകയും ചെയ്യും.
• ഉറവിടങ്ങൾ - നിങ്ങളുടെ പ്രോഗ്രാമിനായുള്ള ഉറവിടങ്ങളുടെ ഒരു ലിസ്റ്റ്.
• ഉൾപ്പെടുന്നു - അസംബ്ലിക്ക് ആവശ്യമായ ഹെഡ്ഡർ ഫയലുകൾ. ഇവിടെ അവർ സാധാരണയായി DDK-യ്‌ക്കൊപ്പം വരുന്ന ഫയലുകളിലേക്കുള്ള പാതയെ സൂചിപ്പിക്കുന്നു, എന്നാൽ നിങ്ങൾക്ക് മറ്റേതെങ്കിലും വ്യക്തമാക്കാൻ കഴിയും.
• TARGETLIBS - ലിങ്ക് ചെയ്യേണ്ട ലൈബ്രറികളുടെ ലിസ്റ്റ്.
• വ്യക്തമായ കാരണങ്ങളാൽ 1 ആയി സജ്ജീകരിക്കേണ്ട ഒരു ആവശ്യമായ ഫീൽഡാണ് USE_NTDLL.
• USER_C_FLAGS - ആപ്ലിക്കേഷൻ കോഡ് തയ്യാറാക്കുമ്പോൾ നിങ്ങൾക്ക് പ്രീപ്രൊസസ്സർ നിർദ്ദേശങ്ങളിൽ ഉപയോഗിക്കാനാകുന്ന ഏതെങ്കിലും ഫ്ലാഗുകൾ.

അതിനാൽ നിർമ്മിക്കുന്നതിന്, നമ്മൾ x86 (അല്ലെങ്കിൽ x64) ചെക്ക്ഡ് ബിൽഡ് പ്രവർത്തിപ്പിക്കേണ്ടതുണ്ട്, വർക്കിംഗ് ഡയറക്ടറി പ്രൊജക്റ്റ് ഫോൾഡറിലേക്ക് മാറ്റി ബിൽഡ് കമാൻഡ് പ്രവർത്തിപ്പിക്കുക. ഞങ്ങൾക്ക് ഒരു എക്സിക്യൂട്ടബിൾ ഫയൽ ഉണ്ടെന്ന് സ്ക്രീൻഷോട്ടിലെ ഫലം കാണിക്കുന്നു.

ഈ ഫയൽ അത്ര എളുപ്പത്തിൽ സമാരംഭിക്കാൻ കഴിയില്ല, ഇനിപ്പറയുന്ന പിശക് ഉപയോഗിച്ച് അതിന്റെ പെരുമാറ്റത്തെക്കുറിച്ച് ചിന്തിക്കാൻ സിസ്റ്റം ശപിക്കുകയും ഞങ്ങളെ അയയ്ക്കുകയും ചെയ്യുന്നു:

ഒരു നേറ്റീവ് ആപ്ലിക്കേഷൻ എങ്ങനെ സമാരംഭിക്കാം?

autochk ആരംഭിക്കുമ്പോൾ, പ്രോഗ്രാമുകളുടെ സ്റ്റാർട്ടപ്പ് ക്രമം നിർണ്ണയിക്കുന്നത് രജിസ്ട്രി കീയുടെ മൂല്യം അനുസരിച്ചാണ്:

HKLMSystemCurrentControlSetControlSession ManagerBootExecute

സെഷൻ മാനേജർ ഈ ലിസ്റ്റിൽ നിന്നുള്ള പ്രോഗ്രാമുകൾ ഓരോന്നായി എക്സിക്യൂട്ട് ചെയ്യുന്നു. സിസ്റ്റം 32 ഡയറക്ടറിയിൽ എക്സിക്യൂട്ടബിൾ ഫയലുകൾക്കായി സെഷൻ മാനേജർ തിരയുന്നു. രജിസ്ട്രി കീ മൂല്യ ഫോർമാറ്റ് ഇപ്രകാരമാണ്:

autocheck autochk *MyNative

മൂല്യം ഹെക്സാഡെസിമൽ ഫോർമാറ്റിലായിരിക്കണം, സാധാരണ ASCII അല്ല, അതിനാൽ മുകളിൽ കാണിച്ചിരിക്കുന്ന കീ ഫോർമാറ്റിലായിരിക്കും:

61,75,74,6f,63,68,65,63,6b,20,61,75,74,6f,63,68,6b,20,2a,00,4d,79,4e,61,74,69,76,65,00,00

ശീർഷകം പരിവർത്തനം ചെയ്യാൻ, നിങ്ങൾക്ക് ഒരു ഓൺലൈൻ സേവനം ഉപയോഗിക്കാം, ഉദാഹരണത്തിന്, ഇത്.

ഒരു നേറ്റീവ് ആപ്ലിക്കേഷൻ സമാരംഭിക്കുന്നതിന്, ഞങ്ങൾക്ക് ഇത് ആവശ്യമാണ്:

1. എക്സിക്യൂട്ടബിൾ ഫയൽ system32 ഫോൾഡറിലേക്ക് പകർത്തുക
2. രജിസ്ട്രിയിലേക്ക് ഒരു കീ ചേർക്കുക
3. മെഷീൻ റീബൂട്ട് ചെയ്യുക

സൗകര്യാർത്ഥം, ഒരു നേറ്റീവ് ആപ്ലിക്കേഷൻ ഇൻസ്റ്റാൾ ചെയ്യുന്നതിനുള്ള ഒരു റെഡിമെയ്ഡ് സ്ക്രിപ്റ്റ് ഇതാ:

install.bat

@echo off
copy MyNative.exe %systemroot%system32.
regedit /s add.reg
echo Native Example Installed
pause

add.reg

REGEDIT4

[HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlSession Manager]
"BootExecute"=hex(7):61,75,74,6f,63,68,65,63,6b,20,61,75,74,6f,63,68,6b,20,2a,00,4d,79,4e,61,74,69,76,65,00,00

ഇൻസ്റ്റാളുചെയ്‌ത് റീബൂട്ട് ചെയ്‌തതിനുശേഷം, ഉപയോക്തൃ തിരഞ്ഞെടുപ്പ് സ്‌ക്രീൻ ദൃശ്യമാകുന്നതിന് മുമ്പുതന്നെ, ഞങ്ങൾക്ക് ഇനിപ്പറയുന്ന ചിത്രം ലഭിക്കും:

ഫലം

അത്തരമൊരു ചെറിയ ആപ്ലിക്കേഷന്റെ ഉദാഹരണം ഉപയോഗിച്ച്, വിൻഡോസ് നേറ്റീവ് തലത്തിൽ ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുന്നത് തികച്ചും സാദ്ധ്യമാണെന്ന് ഞങ്ങൾക്ക് ബോധ്യപ്പെട്ടു. അടുത്തതായി, ഞങ്ങളുടെ പ്രോജക്റ്റിന്റെ മുൻ പതിപ്പിനേക്കാൾ വളരെ നേരത്തെ തന്നെ ഡ്രൈവറുമായി ഇടപഴകുന്ന പ്രക്രിയ ആരംഭിക്കുന്ന ഒരു സേവനം നിർമ്മിക്കുന്നത് ഞാനും ഇന്നോപോളിസ് സർവകലാശാലയിൽ നിന്നുള്ളവരും തുടരും. win32 ഷെല്ലിന്റെ വരവോടെ, ഇതിനകം വികസിപ്പിച്ചെടുത്ത ഒരു സമ്പൂർണ്ണ സേവനത്തിലേക്ക് നിയന്ത്രണം കൈമാറുന്നത് യുക്തിസഹമായിരിക്കും (ഇതിൽ കൂടുതൽ ഇവിടെ).

അടുത്ത ലേഖനത്തിൽ ഞങ്ങൾ സജീവ പുനഃസ്ഥാപിക്കൽ സേവനത്തിന്റെ മറ്റൊരു ഘടകത്തിൽ സ്പർശിക്കും, അതായത് UEFI ഡ്രൈവർ. ഞങ്ങളുടെ ബ്ലോഗ് സബ്‌സ്‌ക്രൈബുചെയ്യുക, അതിനാൽ നിങ്ങൾക്ക് അടുത്ത പോസ്റ്റ് നഷ്‌ടമാകില്ല.

അവലംബം: www.habr.com