ਵਿੰਡੋਜ਼ ਨੇਟਿਵ ਐਪਲੀਕੇਸ਼ਨ ਅਤੇ ਐਕ੍ਰੋਨਿਸ ਐਕਟਿਵ ਰੀਸਟੋਰ ਸੇਵਾ

ਅੱਜ ਅਸੀਂ ਇਸ ਕਹਾਣੀ ਨੂੰ ਜਾਰੀ ਰੱਖਦੇ ਹਾਂ ਕਿ ਕਿਵੇਂ ਅਸੀਂ, ਇਨੋਪੋਲਿਸ ਯੂਨੀਵਰਸਿਟੀ ਦੇ ਮੁੰਡਿਆਂ ਦੇ ਨਾਲ, ਇੱਕ ਅਸਫਲਤਾ ਤੋਂ ਬਾਅਦ ਉਪਭੋਗਤਾ ਨੂੰ ਜਿੰਨੀ ਜਲਦੀ ਹੋ ਸਕੇ ਆਪਣੀ ਮਸ਼ੀਨ 'ਤੇ ਕੰਮ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਨ ਦੀ ਆਗਿਆ ਦੇਣ ਲਈ ਐਕਟਿਵ ਰੀਸਟੋਰ ਤਕਨਾਲੋਜੀ ਦਾ ਵਿਕਾਸ ਕਰ ਰਹੇ ਹਾਂ। ਅਸੀਂ ਮੂਲ ਵਿੰਡੋਜ਼ ਐਪਲੀਕੇਸ਼ਨਾਂ ਬਾਰੇ ਗੱਲ ਕਰਾਂਗੇ, ਜਿਸ ਵਿੱਚ ਉਹਨਾਂ ਦੀ ਰਚਨਾ ਅਤੇ ਲਾਂਚ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸ਼ਾਮਲ ਹਨ। ਕੱਟ ਦੇ ਹੇਠਾਂ ਸਾਡੇ ਪ੍ਰੋਜੈਕਟ ਬਾਰੇ ਥੋੜਾ ਜਿਹਾ ਹੈ, ਨਾਲ ਹੀ ਨੇਟਿਵ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ ਇਸ ਬਾਰੇ ਇੱਕ ਵਿਹਾਰਕ ਗਾਈਡ ਹੈ।

ਪਿਛਲੀਆਂ ਪੋਸਟਾਂ ਵਿੱਚ ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਇਸ ਬਾਰੇ ਗੱਲ ਕਰ ਚੁੱਕੇ ਹਾਂ ਕਿ ਇਹ ਕੀ ਹੈ ਕਿਰਿਆਸ਼ੀਲ ਰੀਸਟੋਰ, ਅਤੇ ਇਨੋਪੋਲਿਸ ਦੇ ਵਿਦਿਆਰਥੀ ਕਿਵੇਂ ਵਿਕਸਿਤ ਹੁੰਦੇ ਹਨ ਸੇਵਾ. ਅੱਜ ਮੈਂ ਮੂਲ ਐਪਲੀਕੇਸ਼ਨਾਂ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹਾਂ, ਜਿਸ ਪੱਧਰ ਤੱਕ ਅਸੀਂ ਆਪਣੀ ਸਰਗਰਮ ਰਿਕਵਰੀ ਸੇਵਾ ਨੂੰ "ਦਫਨਾਉਣਾ" ਚਾਹੁੰਦੇ ਹਾਂ। ਜੇ ਸਭ ਕੁਝ ਕੰਮ ਕਰਦਾ ਹੈ, ਤਾਂ ਅਸੀਂ ਇਹ ਕਰਨ ਦੇ ਯੋਗ ਹੋਵਾਂਗੇ:

• ਸੇਵਾ ਨੂੰ ਬਹੁਤ ਪਹਿਲਾਂ ਲਾਂਚ ਕਰੋ
• ਕਲਾਉਡ ਨਾਲ ਸੰਪਰਕ ਕਰੋ ਜਿੱਥੇ ਬੈਕਅੱਪ ਬਹੁਤ ਪਹਿਲਾਂ ਸਥਿਤ ਹੈ
• ਇਹ ਸਮਝਣ ਲਈ ਬਹੁਤ ਪਹਿਲਾਂ ਕਿ ਸਿਸਟਮ ਕਿਸ ਮੋਡ ਵਿੱਚ ਹੈ - ਸਧਾਰਨ ਬੂਟ ਜਾਂ ਰਿਕਵਰੀ
• ਪਹਿਲਾਂ ਤੋਂ ਰਿਕਵਰ ਕਰਨ ਲਈ ਬਹੁਤ ਘੱਟ ਫਾਈਲਾਂ
• ਉਪਭੋਗਤਾ ਨੂੰ ਹੋਰ ਵੀ ਤੇਜ਼ੀ ਨਾਲ ਸ਼ੁਰੂ ਕਰਨ ਦਿਓ।

ਵੈਸੇ ਵੀ ਇੱਕ ਮੂਲ ਐਪ ਕੀ ਹੈ?

ਇਸ ਸਵਾਲ ਦਾ ਜਵਾਬ ਦੇਣ ਲਈ, ਆਉ ਸਿਸਟਮ ਦੁਆਰਾ ਕੀਤੀਆਂ ਗਈਆਂ ਕਾਲਾਂ ਦੇ ਕ੍ਰਮ ਨੂੰ ਵੇਖੀਏ, ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਉਸਦੀ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਇੱਕ ਪ੍ਰੋਗਰਾਮਰ ਇੱਕ ਫਾਈਲ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ.

ਪਾਵੇਲ ਯੋਸੀਫੋਵਿਚ - ਵਿੰਡੋਜ਼ ਕਰਨਲ ਪ੍ਰੋਗਰਾਮਿੰਗ (2019)

ਪ੍ਰੋਗਰਾਮਰ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਫਾਈਲ ਬਣਾਓ, ਜਿਸ ਨੂੰ ਹੈਡਰ ਫਾਈਲ fileapi.h ਵਿੱਚ ਘੋਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ Kernel32.dll ਵਿੱਚ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ। ਹਾਲਾਂਕਿ, ਇਹ ਫੰਕਸ਼ਨ ਖੁਦ ਫਾਈਲ ਨਹੀਂ ਬਣਾਉਂਦਾ, ਇਹ ਸਿਰਫ ਇਨਪੁਟ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ ਅਤੇ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ NtCreateFile (ਅਗੇਤਰ Nt ਸਿਰਫ਼ ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਫੰਕਸ਼ਨ ਮੂਲ ਹੈ)। ਇਹ ਫੰਕਸ਼ਨ winternl.h ਹੈਡਰ ਫਾਈਲ ਵਿੱਚ ਘੋਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ntdll.dll ਵਿੱਚ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਹ ਪ੍ਰਮਾਣੂ ਸਪੇਸ ਵਿੱਚ ਛਾਲ ਮਾਰਨ ਦੀ ਤਿਆਰੀ ਕਰਦਾ ਹੈ, ਜਿਸ ਤੋਂ ਬਾਅਦ ਇਹ ਇੱਕ ਫਾਈਲ ਬਣਾਉਣ ਲਈ ਇੱਕ ਸਿਸਟਮ ਕਾਲ ਕਰਦਾ ਹੈ। ਇਸ ਕੇਸ ਵਿੱਚ, ਇਹ ਪਤਾ ਚਲਦਾ ਹੈ ਕਿ Kernel32 Ntdll ਲਈ ਸਿਰਫ਼ ਇੱਕ ਰੈਪਰ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਦਾ ਇੱਕ ਕਾਰਨ ਇਹ ਹੈ ਕਿ ਮਾਈਕ੍ਰੋਸਾੱਫਟ ਇਸ ਤਰ੍ਹਾਂ ਮੂਲ ਸੰਸਾਰ ਦੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਬਦਲਣ ਦੀ ਸਮਰੱਥਾ ਰੱਖਦਾ ਹੈ, ਪਰ ਮਿਆਰੀ ਇੰਟਰਫੇਸਾਂ ਨੂੰ ਛੂਹ ਨਹੀਂ ਸਕਦਾ। ਮਾਈਕ੍ਰੋਸਾਫਟ ਨੇਟਿਵ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਸਿੱਧੇ ਕਾਲ ਕਰਨ ਦੀ ਸਿਫ਼ਾਰਿਸ਼ ਨਹੀਂ ਕਰਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਵਿੱਚੋਂ ਜ਼ਿਆਦਾਤਰ ਨੂੰ ਦਸਤਾਵੇਜ਼ ਨਹੀਂ ਕਰਦਾ ਹੈ। ਤਰੀਕੇ ਨਾਲ, ਬਿਨਾਂ ਦਸਤਾਵੇਜ਼ੀ ਫੰਕਸ਼ਨ ਲੱਭੇ ਜਾ ਸਕਦੇ ਹਨ ਇੱਥੇ.

ਨੇਟਿਵ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦਾ ਮੁੱਖ ਫਾਇਦਾ ਇਹ ਹੈ ਕਿ ntdll ਸਿਸਟਮ ਵਿੱਚ kernel32 ਤੋਂ ਬਹੁਤ ਪਹਿਲਾਂ ਲੋਡ ਹੁੰਦਾ ਹੈ। ਇਹ ਲਾਜ਼ੀਕਲ ਹੈ, ਕਿਉਂਕਿ kernel32 ਨੂੰ ਕੰਮ ਕਰਨ ਲਈ ntdll ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਨਤੀਜੇ ਵਜੋਂ, ਨੇਟਿਵ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਵਾਲੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਬਹੁਤ ਪਹਿਲਾਂ ਕੰਮ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਸਕਦੀਆਂ ਹਨ।

ਇਸ ਤਰ੍ਹਾਂ, ਵਿੰਡੋਜ਼ ਨੇਟਿਵ ਐਪਲੀਕੇਸ਼ਨ ਉਹ ਪ੍ਰੋਗਰਾਮ ਹਨ ਜੋ ਵਿੰਡੋਜ਼ ਬੂਟ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਸ਼ੁਰੂ ਹੋ ਸਕਦੇ ਹਨ। ਉਹ ਸਿਰਫ ntdll ਤੋਂ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ। ਅਜਿਹੀ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਇੱਕ ਉਦਾਹਰਣ: autochk ਜੋ ਪ੍ਰਦਰਸ਼ਨ ਕਰਦਾ ਹੈ chkdisk ਸਹੂਲਤ ਮੁੱਖ ਸੇਵਾਵਾਂ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਗਲਤੀਆਂ ਲਈ ਡਿਸਕ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ। ਇਹ ਬਿਲਕੁਲ ਉਹ ਪੱਧਰ ਹੈ ਜੋ ਅਸੀਂ ਚਾਹੁੰਦੇ ਹਾਂ ਕਿ ਸਾਡੀ ਐਕਟਿਵ ਰੀਸਟੋਰ ਹੋਵੇ।

ਸਾਨੂੰ ਕੀ ਚਾਹੀਦਾ ਹੈ?

• ਡੀ.ਡੀ.ਕੇ (ਡਰਾਈਵਰ ਡਿਵੈਲਪਮੈਂਟ ਕਿੱਟ), ਹੁਣ WDK 7 (ਵਿੰਡੋਜ਼ ਡਰਾਈਵਰ ਕਿੱਟ) ਵਜੋਂ ਵੀ ਜਾਣੀ ਜਾਂਦੀ ਹੈ।
• ਵਰਚੁਅਲ ਮਸ਼ੀਨ (ਉਦਾਹਰਨ ਲਈ, ਵਿੰਡੋਜ਼ 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 ਨੂੰ ਇੱਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਨਾਲ ਕਨੈਕਟ ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ। ਇਹ ਕਿਵੇਂ ਕਰਨਾ ਹੈ ਇਸ ਬਾਰੇ ਹਦਾਇਤਾਂ ਲੱਭੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ ਇੱਥੇ ਜਾਂ ਸਿਰਫ ਵਰਤੋਂ ਵਰਚੁਅਲ ਕੇ.ਡੀ.

ਸੰਕਲਨ ਅਤੇ ਅਸੈਂਬਲੀ

ਨੇਟਿਵ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਦਾ ਸਭ ਤੋਂ ਆਸਾਨ ਤਰੀਕਾ ਹੈ ਵਰਤਣਾ ਡੀ.ਡੀ.ਕੇ (ਡਰਾਈਵਰ ਡਿਵੈਲਪਮੈਂਟ ਕਿੱਟ)। ਸਾਨੂੰ ਪ੍ਰਾਚੀਨ ਸੱਤਵੇਂ ਸੰਸਕਰਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ, ਕਿਉਂਕਿ ਬਾਅਦ ਦੇ ਸੰਸਕਰਣਾਂ ਵਿੱਚ ਥੋੜ੍ਹਾ ਵੱਖਰਾ ਤਰੀਕਾ ਹੈ ਅਤੇ ਵਿਜ਼ੂਅਲ ਸਟੂਡੀਓ ਦੇ ਨਾਲ ਮਿਲ ਕੇ ਕੰਮ ਕਰਦੇ ਹਨ। ਜੇਕਰ ਅਸੀਂ DDK ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਸਾਡੇ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਸਿਰਫ਼ ਮੇਕਫਾਈਲ ਅਤੇ ਸਰੋਤਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

ਮੇਕਫਾਈਲ

!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

ਤੁਹਾਡੀ ਮੇਕਫਾਈਲ ਬਿਲਕੁਲ ਉਹੀ ਹੋਵੇਗੀ, ਪਰ ਆਓ ਥੋੜੇ ਹੋਰ ਵਿਸਥਾਰ ਵਿੱਚ ਸਰੋਤਾਂ ਨੂੰ ਵੇਖੀਏ. ਇਹ ਫਾਈਲ ਤੁਹਾਡੇ ਪ੍ਰੋਗਰਾਮ ਦੇ ਸਰੋਤਾਂ (.c ਫਾਈਲਾਂ), ਬਿਲਡ ਵਿਕਲਪਾਂ ਅਤੇ ਹੋਰ ਮਾਪਦੰਡਾਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ।

• TARGETNAME – ਚੱਲਣਯੋਗ ਫਾਈਲ ਦਾ ਨਾਮ ਜੋ ਅੰਤ ਵਿੱਚ ਤਿਆਰ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।
• TARGETTYPE - ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਫਾਈਲ ਦੀ ਕਿਸਮ, ਇਹ ਇੱਕ ਡਰਾਈਵਰ (.sys) ਹੋ ਸਕਦੀ ਹੈ, ਫਿਰ ਫੀਲਡ ਦਾ ਮੁੱਲ ਡ੍ਰਾਈਵਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਜੇਕਰ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ (.lib), ਤਾਂ ਮੁੱਲ LIBRARY ਹੈ। ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਸਾਨੂੰ ਇੱਕ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਫਾਈਲ (.exe) ਦੀ ਲੋੜ ਹੈ, ਇਸਲਈ ਅਸੀਂ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਮੁੱਲ ਸੈੱਟ ਕਰਦੇ ਹਾਂ।
• UMTYPE – ਇਸ ਖੇਤਰ ਲਈ ਸੰਭਵ ਮੁੱਲ: ਇੱਕ ਕੰਸੋਲ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਕੰਸੋਲ, ਵਿੰਡੋਜ਼ ਮੋਡ ਵਿੱਚ ਕੰਮ ਕਰਨ ਲਈ ਵਿੰਡੋਜ਼। ਪਰ ਸਾਨੂੰ ਨੇਟਿਵ ਐਪਲੀਕੇਸ਼ਨ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ nt ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।
• BUFFER_OVERFLOW_CHECKS - ਬਫਰ ਓਵਰਫਲੋ ਲਈ ਸਟੈਕ ਦੀ ਜਾਂਚ ਕਰਨਾ, ਬਦਕਿਸਮਤੀ ਨਾਲ ਸਾਡੇ ਕੇਸ ਨਹੀਂ, ਅਸੀਂ ਇਸਨੂੰ ਬੰਦ ਕਰ ਦਿੰਦੇ ਹਾਂ।
• MINWIN_SDK_LIB_PATH - ਇਹ ਮੁੱਲ SDK_LIB_PATH ਵੇਰੀਏਬਲ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ, ਚਿੰਤਾ ਨਾ ਕਰੋ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਅਜਿਹਾ ਸਿਸਟਮ ਵੇਰੀਏਬਲ ਘੋਸ਼ਿਤ ਨਹੀਂ ਹੈ, ਜਦੋਂ ਅਸੀਂ DDK ਤੋਂ ਚੈੱਕ ਕੀਤੇ ਬਿਲਡ ਨੂੰ ਚਲਾਉਂਦੇ ਹਾਂ, ਤਾਂ ਇਹ ਵੇਰੀਏਬਲ ਘੋਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇਗਾ ਅਤੇ ਲੋੜੀਂਦੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰੇਗਾ।
• ਸਰੋਤ – ਤੁਹਾਡੇ ਪ੍ਰੋਗਰਾਮ ਲਈ ਸਰੋਤਾਂ ਦੀ ਸੂਚੀ।
• ਸ਼ਾਮਲ ਹਨ - ਹੈਡਰ ਫਾਈਲਾਂ ਜੋ ਅਸੈਂਬਲੀ ਲਈ ਲੋੜੀਂਦੀਆਂ ਹਨ। ਇੱਥੇ ਉਹ ਆਮ ਤੌਰ 'ਤੇ ਫਾਈਲਾਂ ਦਾ ਮਾਰਗ ਦਰਸਾਉਂਦੇ ਹਨ ਜੋ DDK ਨਾਲ ਆਉਂਦੀਆਂ ਹਨ, ਪਰ ਤੁਸੀਂ ਇਸ ਤੋਂ ਇਲਾਵਾ ਕਿਸੇ ਹੋਰ ਨੂੰ ਵੀ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ।
• TARGETLIBS - ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਸੂਚੀ ਜਿਨ੍ਹਾਂ ਨੂੰ ਲਿੰਕ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।
• USE_NTDLL ਇੱਕ ਲੋੜੀਂਦਾ ਖੇਤਰ ਹੈ ਜੋ ਸਪੱਸ਼ਟ ਕਾਰਨਾਂ ਕਰਕੇ 1 'ਤੇ ਸੈੱਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।
• USER_C_FLAGS - ਕੋਈ ਵੀ ਫਲੈਗ ਜੋ ਤੁਸੀਂ ਐਪਲੀਕੇਸ਼ਨ ਕੋਡ ਤਿਆਰ ਕਰਦੇ ਸਮੇਂ ਪ੍ਰੀਪ੍ਰੋਸੈਸਰ ਨਿਰਦੇਸ਼ਾਂ ਵਿੱਚ ਵਰਤ ਸਕਦੇ ਹੋ।

ਇਸ ਲਈ ਬਿਲਡ ਕਰਨ ਲਈ, ਸਾਨੂੰ x86 (ਜਾਂ x64) ਚੈੱਕਡ ਬਿਲਡ ਨੂੰ ਚਲਾਉਣ ਦੀ ਲੋੜ ਹੈ, ਵਰਕਿੰਗ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਪ੍ਰੋਜੈਕਟ ਫੋਲਡਰ ਵਿੱਚ ਬਦਲੋ ਅਤੇ ਬਿਲਡ ਕਮਾਂਡ ਚਲਾਓ। ਸਕਰੀਨਸ਼ਾਟ ਵਿੱਚ ਨਤੀਜਾ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਸਾਡੇ ਕੋਲ ਇੱਕ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਫਾਈਲ ਹੈ।

ਇਹ ਫਾਈਲ ਇੰਨੀ ਆਸਾਨੀ ਨਾਲ ਲਾਂਚ ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ, ਸਿਸਟਮ ਸਰਾਪ ਦਿੰਦਾ ਹੈ ਅਤੇ ਸਾਨੂੰ ਹੇਠਾਂ ਦਿੱਤੀ ਗਲਤੀ ਨਾਲ ਇਸਦੇ ਵਿਵਹਾਰ ਬਾਰੇ ਸੋਚਣ ਲਈ ਭੇਜਦਾ ਹੈ:

ਇੱਕ ਨੇਟਿਵ ਐਪਲੀਕੇਸ਼ਨ ਕਿਵੇਂ ਲਾਂਚ ਕਰੀਏ?

ਜਦੋਂ ਆਟੋਚੱਕ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਪ੍ਰੋਗਰਾਮਾਂ ਦਾ ਸ਼ੁਰੂਆਤੀ ਕ੍ਰਮ ਰਜਿਸਟਰੀ ਕੁੰਜੀ ਦੇ ਮੁੱਲ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ:

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. ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਫਾਈਲ ਨੂੰ ਸਿਸਟਮ 32 ਫੋਲਡਰ ਵਿੱਚ ਕਾਪੀ ਕਰੋ
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

ਇੰਸਟਾਲੇਸ਼ਨ ਅਤੇ ਰੀਬੂਟ ਤੋਂ ਬਾਅਦ, ਉਪਭੋਗਤਾ ਚੋਣ ਸਕ੍ਰੀਨ ਦੇ ਆਉਣ ਤੋਂ ਪਹਿਲਾਂ ਹੀ, ਸਾਨੂੰ ਹੇਠ ਲਿਖੀ ਤਸਵੀਰ ਮਿਲੇਗੀ:

ਨਤੀਜਾ

ਅਜਿਹੀ ਛੋਟੀ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਉਦਾਹਰਣ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਸਾਨੂੰ ਯਕੀਨ ਹੋ ਗਿਆ ਸੀ ਕਿ ਵਿੰਡੋਜ਼ ਨੇਟਿਵ ਪੱਧਰ 'ਤੇ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਚਲਾਉਣਾ ਕਾਫ਼ੀ ਸੰਭਵ ਹੈ। ਅੱਗੇ, ਇਨੋਪੋਲਿਸ ਯੂਨੀਵਰਸਿਟੀ ਦੇ ਮੁੰਡੇ ਅਤੇ ਮੈਂ ਇੱਕ ਸੇਵਾ ਬਣਾਉਣਾ ਜਾਰੀ ਰੱਖਾਂਗੇ ਜੋ ਸਾਡੇ ਪ੍ਰੋਜੈਕਟ ਦੇ ਪਿਛਲੇ ਸੰਸਕਰਣ ਨਾਲੋਂ ਬਹੁਤ ਪਹਿਲਾਂ ਡਰਾਈਵਰ ਨਾਲ ਗੱਲਬਾਤ ਦੀ ਪ੍ਰਕਿਰਿਆ ਸ਼ੁਰੂ ਕਰੇਗੀ। ਅਤੇ ਵਿਨ 32 ਸ਼ੈੱਲ ਦੇ ਆਗਮਨ ਦੇ ਨਾਲ, ਨਿਯੰਤਰਣ ਨੂੰ ਇੱਕ ਪੂਰੀ ਸੇਵਾ ਵਿੱਚ ਤਬਦੀਲ ਕਰਨਾ ਲਾਜ਼ੀਕਲ ਹੋਵੇਗਾ ਜੋ ਪਹਿਲਾਂ ਹੀ ਵਿਕਸਤ ਕੀਤੀ ਜਾ ਚੁੱਕੀ ਹੈ (ਇਸ ਬਾਰੇ ਹੋਰ ਇੱਥੇ).

ਅਗਲੇ ਲੇਖ ਵਿੱਚ ਅਸੀਂ ਐਕਟਿਵ ਰੀਸਟੋਰ ਸੇਵਾ ਦੇ ਇੱਕ ਹੋਰ ਹਿੱਸੇ ਨੂੰ ਛੂਹਾਂਗੇ, ਅਰਥਾਤ UEFI ਡਰਾਈਵਰ। ਸਾਡੇ ਬਲੌਗ ਦੀ ਗਾਹਕੀ ਲਓ ਤਾਂ ਜੋ ਤੁਸੀਂ ਅਗਲੀ ਪੋਸਟ ਨੂੰ ਨਾ ਖੁੰਝੋ।

ਸਰੋਤ: www.habr.com