Próba stworzenia mechanizmu autoochrony w C#

Przez ostatnie kilka dni siedziałem, wykorzystywałem przycisk „Search” w wyszukiwarce Google aż nazbyt dużo razy, gdyż próbowałem znaleźć jakiś sposób, na autoochronę w C#. Jest to strasznie ciekawe zagadnienie, dlatego postanowiłem o tym napisać. Od razu mówię, post nie będzie zbyt ładny, tekst będzie dość precyzyjny.

UWAGA
Aby zakończyć proces uruchomiony z użyciem następującego kodu, wymagane są uprawnienia administratora (ring 1), a więc sposób ten nie jest całkowicie efektywny. Krótko mówiąc, działa on na takiej zasadzie – uruchamia proces z wirtualnego konta innego użytkownika, co wykorzystuje Windowsowe restrykcje do zablokowania możliwości ubicia procesu, jeśli nie ma się wystarczających uprawnień.

Wykorzystane źródła (większość MSDN, trochę pinvoke (bez którego trwało by to wieki (znajdowanie DLL z danymi funkcjami w systemowym API pod C# <3)) i jeden blog, gość pisał niemal to samo co ja (znalazłem jak szukałem informacji o RawSecurityDescriptor)):

Cały kod jest dostępny tutaj: http://pastebin.com/JzaA9fCu

A więc prócz zadeklarowanych przestrzeni nazw, musimy pobawić się trochę z WinAPI, a szczególnie dwoma bibliotekami – advapi32.dll oraz kernel32.dll. Będziemy potrzebować tylko kilku funkcji.

Zacznijmy od advapi32 i funkcji GetKernelObjectSecurity (boolean):

DllImport("advapi32.dll", SetLastError = true)]
private static extern bool GetKernelObjectSecurity(IntPtr handle, int secInfo, [Out] byte[] sDescriptor, uint len, out uint len2);

 

Dalej advapi32 i funckja SetKernelObjectSecurity (boolean, analogicznie – tu set, tam get)

[DllImport("advapi32.dll", SetLastError = true)]
private static extern bool SetKernelObjectSecurity(IntPtr Handle, int secInfo, [In] byte[] psd);

 

 

 Tym razem pseudo uchwyt do procesu, który weźmiemy z kernel32.dll
      [DllImport(&quot;kernel32.dll&quot;)]
      private static extern IntPtr GetCurrentProcess();

Teraz tworzymy obiekt RawSecurityDesriptor (znajdujący się w
System.Security.AccessControl), będący naszym swego rodzaju getterem (będzie zbierał właściwości procesu poprzez uchwyt do niego).

private static RawSecurityDescriptor GetProcessSecurityDescriptor(IntPtr processHandle)
{
const int DACL_SECURITY_INFORMATION = 0x00000004;
byte[] psecdesc = new byte[0];
uint BytesNeed;

GetKernelObjectSecurity(processHandle, DACL_SECURITY_INFORMATION, psecdesc, 0, out BytesNeed);
if (BytesNeed < 0 || BytesNeed > short.MaxValue)
throw new Win32Exception();

if (!GetKernelObjectSecurity(processHandle,
DACL_SECURITY_INFORMATION,
psecdesc = new byte[BytesNeed],
BytesNeed, out BytesNeed)) throw new Win32Exception();

return new RawSecurityDescriptor(psecdesc, 0);
}

 

 

Co tu się dzieje? Jako argument funkcji mamy podać uchwyt do aktualnego procesu. Zgodnie z MSDN tworzymy stały typ int o wartości 0x00000004 (advice WinAPI), dalej tablicę bajtów o zerowej wielkości, i typ int bez znaku, w którym określimy potem ilość bajtów które muszą zostać sparsowane. Teraz korzystamy z naszego „gettera” -> getKernelObjSec (pierwszy omówiony dllimport) z takimi argumentami, które ta funkcja WinAPI wymaga. Wyrzuci ona nam jednak do naszego uinta BytesNeed pewną ilość, która jest nam potrzebna do poprawnego działania aplikacji. Jeżeli jest < 0 albo większe od  32767 wyrzuci ona nam wyjątek (MSDN), podobnie, jeżeli operacja „gettera” się nam nie uda (jest on typem BOOL). W przeciwnym razie (który dzieje się prawie zawsze) zostanie nam zwrócony poprawny RawSecurityDescriptor (dokładnie DACL (Discretionary Access Control List)), na którym możemy spokojnie operować.

Teraz stworzyliśmy coś w stylu gettera na DACL, teraz musimy mieć możliwość ustawienia go wedle naszych własnych preferencji.

private static void setProcessSecurityDescriptor(IntPtr processHandle, RawSecurityDescriptor dacl) //ustawiamy DACL
 {
           const int DACL_SECURITY_INFORMATION = 0x00000004;
           byte[] rawSecurityDescriptor = new byte[dacl.BinaryLength];
           dacl.GetBinaryForm(rawSecurityDescriptor, 0);
           if (!SetKernelObjectSecurity(processHandle, DACL_SECURITY_INFORMATION, rawSecurityDescriptor)) throw new Win32Exception();
 }

W argumentach pobieramy uchwyt do naszego procesu i wcześniej wczytany RSD/DACL. Jest to zwyczajna funkcja typu void, nad którą jak myślę nie trzeba się rozwodzić.

Teraz musimy stworzyć coś w stylu listy z wartościami wykorzystywanymi przez WinAPI, a dokładniej DACL i ACE (Access Control Entries). Nadaje się do tego idealnie enum, w którym to zhardcodujemy te wartości (a w zasadzie flagi). Jak zwykle MSDN jest naszym zbawieniem.

[Flags]
       private enum PAR //flagi dostępu do procesów --> Process Access Rights po kolei z MSDN
       {
           PROCESS_CREATE_PROCESS = 0x0080,                                        //do tworzenia procesu
           PROCESS_CREATE_THREAD = 0x0002,                                         //do tworzenia wątku
           SYNCHRONIZE = 0x00100000,                                               //synchronizacja (?)
           PROCESS_DUP_HANDLE = 0x0040,                                            //do łapania uchwytu
           PROCESS_QUERY_INFORMATION = 0x0400,                                     //do zdobywania informacji o procesie (token etc.)
           PROCESS_QUERY_LIMITED_INFORMATION = 0x1000,                             //do zdobywania innych informacji, analogiczne
           PROCESS_SET_QUOTA = 0x0100,                                             //do ingerencji w working set
           PROCESS_SET_INFORMATION = 0x0200,                                       //do ustawiania dla procesu X informacji
           WRITE_OWNER = 0x00080000,                                               //process owner - &amp;quot;posiadacz&amp;quot; procesu - chodzi o konto
           PROCESS_SUSPEND_RESUME = 0x0800,                                        //jak wskazuje nazwa, wstrzymaj lub wznów
           PROCESS_TERMINATE = 0x0001,                                             //zakończ proces
           PROCESS_VM_OPERATION = 0x0008,                                          //zawiera w sobie funkcję - WriteProcessMemory (kernel32.dll -&amp;gt; zawiera się w &amp;lt;windows.h&amp;gt;)
           PROCESS_VM_READ = 0x0010,                                               //do odczytywania pamięci procesu
           PROCESS_VM_WRITE = 0x0020,                                              //do nadpisywania pamięci procesu
           DELETE = 0x00010000,                                                    //do usuwania niektórych rzeczy
           READ_CONTROL = 0x00020000,                                              //kontrola odczytu
           WRITE_DAC = 0x00040000,                                                 //advice DACL
           STANDARD_RIGHTS_REQUIRED = 0x000f0000,                                  //nie mam pojęcia jak to wyjaśnić, ale nazwa STANDARD_RIGHTS_REQUIRED powinna być wystarczająca 😉
           PROCESS_ALL_ACCESS = (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0xFFF),  //reszta
       } ;

 

 

I w zasadzie tyle. Teraz pozostało nam tylko stworzyć nowe ACE i powiedzieć programowi, aby z nich korzystał. Robi się to mniej więcej tak (żywcem z tamtego bloga):

IntPtr hProcess = GetCurrentProcess();
var dacl = GetProcessSecurityDescriptor(hProcess);
dacl.DiscretionaryAcl.InsertAce(0, new CommonAce(AceFlags.None, AceQualifier.AccessDenied /* blokujemy dostęp do procesu */, (int)PAR.PROCESS_ALL_ACCESS, new SecurityIdentifier(WellKnownSidType.WorldSid, null), false, null));
SetProcessSecurityDescriptor(hProcess, dacl);

 

 

Ja to sobie wrzuciłem do voida, i mam to jako funkcję. Spróbujmy teraz dany program tak uruchomiony „zabić”. (polecenie taskkill /im <nazwapliku>)
[Obrazek: tR9f2RC.png]
Jak widać działa! Nie mamy możliwości zakończenia działania procesu bez uprawnień administratora.
To by było na tyle, jeżeli macie pomysły jak lepiej napisać taki mechanizm, proszę piszcie, także, jak czegoś nie rozumiecie również.

Reklamy

Skomentuj

Wprowadź swoje dane lub kliknij jedną z tych ikon, aby się zalogować:

Logo WordPress.com

Komentujesz korzystając z konta WordPress.com. Wyloguj / Zmień )

Zdjęcie z Twittera

Komentujesz korzystając z konta Twitter. Wyloguj / Zmień )

Zdjęcie na Facebooku

Komentujesz korzystając z konta Facebook. Wyloguj / Zmień )

Zdjęcie na Google+

Komentujesz korzystając z konta Google+. Wyloguj / Zmień )

Connecting to %s