Projektowanie aplikacji do uruchamiania na niskim poziomie integralności

Łatwym sposobem uruchamiania procesu aplikacji na niskim poziomie integralności jest ustawienie poziomu integralności pliku programu wykonywalnego na niską integralność. Po uruchomieniu tego pliku obrazu proces aplikacji jest uruchamiany z niskim poziomem integralności. Załóżmy na przykład, że chcemy uruchomić aplikację Kalkulator systemu Windows w procesie niskiej integralności.

Aby uruchomić calc.exe przy niskiej integralności

1. Utwórz kopię c:\Windows\system32\calc.exe do folderu tymczasowego.

2. Użyj programu icacls, aby ustawić poziom integralności pliku tymczasowego, lowcalc.exe, na niską integralność za pomocą polecenia icacls:

   icacls lowcalc.exe /setintegritylevel Low

3. Uruchom wersję calc.exe o niskiej integralności.

Na poniższej ilustracji przedstawiono kroki uruchamiania kalkulatora systemu Windows w procesie o niskiej integralności.

Rysunek 9 Uruchamianie kalkulatora systemu Windows przy niskiej integralności

Możesz użyć Eksploratora procesów, aby potwierdzić, że plik obrazu, lowcalc.exe, rzeczywiście działa z niską integralnością. Kolumna Poziom integralności znajduje się po prawej stronie obrazu.

Rysunek 10 Proces kalkulatora niskiego poziomu

Nie wszystkie programy aplikacji będą działać prawidłowo w procesie o niskiej integralności. Proces niskiej integralności nie ma dostępu do zapisu do większości obszarów w obszarze profilu lokalnego użytkownika systemu plików lub rejestru w ramach HKCU. Brak możliwości uzyskania dostępu do zapisu w profilu użytkownika przez proces o niskiej integralności jest dobrym rozwiązaniem, jeśli program jest niechcianym złośliwym oprogramowaniem. Jednak w przypadku aplikacji, takich jak Tryb chroniony, internet Explorer, niektóre przeprojektowanie może być konieczne, aby wszystkie funkcje aplikacji zachowywały się poprawnie.

Użyj przydatnych narzędzi, takich jak Monitor procesów z Sysinternals.com, aby dowiedzieć się, jakie zasoby plików i rejestru są obecnie używane przez aplikację na potrzeby dostępu do zapisu, który zakończy się niepowodzeniem podczas uruchamiania przy niskiej integralności.

Chociaż istnieje możliwość zmiany aplikacji na działanie całkowicie przy niskiej integralności, niektóre funkcje aplikacji mogą działać prawidłowo tylko wtedy, gdy są implementowane w procesie średniej integralności. Aplikacja, która działa z małą integralnością, może mieć jedną część aplikacji w procesie o niskiej integralności, na przykład w celu obsługi niezaufanych danych z Internetu. Inną częścią aplikacji można zaimplementować w procesie "brokera" o średniej integralności w celu obsługi małego zestawu akcji inicjowanych przez użytkownika. Komunikacja między procesami o niskiej integralności i średniej integralności w aplikacji może być obsługiwana przy użyciu różnych mechanizmów IPC. Część aplikacji o średniej integralności musi zakładać, że wszystkie dane i kod w procesie niskiej integralności są niegodne zaufania.

Program Internet Explorer w trybie chronionym to jedna aplikacja, która została przeprojektowana do uruchamiania w procesie o niskiej integralności. Aby uzyskać więcej informacji na temat programu Internet Explorer w trybie chronionym, zobacz Omówienie i praca w trybie chronionym w programie Internet Explorer (https://go.microsoft.com/fwlink/?LinkId=90931).

Główne tematy projektowania aplikacji do uruchamiania z małą integralnością są następujące:

• Uruchamianie procesu podrzędnego przy niskiej integralności
• Lokalizacje z możliwością zapisu dla aplikacji o niskiej integralności
• Komunikacja między procesami o niskiej integralności i wyższym poziomie

Rozpoczynanie procesu przy niskiej integralności

Domyślnie procesy podrzędne dziedziczą poziom integralności procesu nadrzędnego. Aby rozpocząć proces o niskiej integralności, należy uruchomić nowy proces podrzędny z tokenem dostępu o niskiej integralności przy użyciu funkcji CreateProcessAsUser. Aby rozpocząć proces o niskiej integralności z poziomu procesu o średniej integralności, należy jawnie uruchomić nowy proces jako niski poziom integralności.

Aby rozpocząć proces o niskiej integralności

1. Zduplikuj uchwyt bieżącego procesu, który jest na średnim poziomie integralności.

2. Użyj polecenia SetTokenInformation, aby ustawić poziom integralności w tokenie dostępu na niski.

3. Użyj metody CreateProcessAsUser, aby utworzyć nowy proces przy użyciu dojścia do tokenu dostępu o niskiej integralności.

CreateProcessAsUser aktualizuje deskryptor zabezpieczeń w nowym procesie podrzędnym i deskryptor zabezpieczeń tokenu dostępu, aby był zgodny z poziomem integralności tokenu dostępu o niskiej integralności.

Poniższy przykład kodu demonstruje ten proces.

void CreateLowProcess()
{
 
    BOOL                  fRet;
    HANDLE                hToken        = NULL;
    HANDLE                hNewToken     = NULL;
    PSID                  pIntegritySid = NULL;
    TOKEN_MANDATORY_LABEL TIL           = {0};
    PROCESS_INFORMATION   ProcInfo      = {0};
    STARTUPINFO           StartupInfo   = {0};

 // Notepad is used as an example
 WCHAR wszProcessName[MAX_PATH] =
   L"C:\\Windows\\System32\\Notepad.exe";

 // Low integrity SID
 WCHAR wszIntegritySid[20] = L"S-1-16-1024";
 PSID pIntegritySid = NULL;

    fRet = OpenProcessToken(GetCurrentProcess(),
                            TOKEN_DUPLICATE |
                              TOKEN_ADJUST_DEFAULT |
                              TOKEN_QUERY |
                              TOKEN_ASSIGN_PRIMARY,
                            &hToken);

    if (!fRet)
    {
        goto CleanExit;
    }

    fRet = DuplicateTokenEx(hToken,
                            0,
                            NULL,
                            SecurityImpersonation,
                            TokenPrimary,
                            &hNewToken);

    if (!fRet)
    {
        goto CleanExit;
    }

    fRet = ConvertStringSidToSid(wszIntegritySid, &pIntegritySid);

    if (!fRet)
    {
        goto CleanExit;
    }

    TIL.Label.Attributes = SE_GROUP_INTEGRITY;
    TIL.Label.Sid        = pIntegritySid;

    //
    // Set the process integrity level
    //

    fRet = SetTokenInformation(hNewToken,
                               TokenIntegrityLevel,
                               &TIL,
                               sizeof(TOKEN_MANDATORY_LABEL) + GetLengthSid(pIntegritySid));

    if (!fRet)
    {
        goto CleanExit;
    }

    //
    // Create the new process at Low integrity
    //

    fRet  = CreateProcessAsUser(hNewToken,
                                NULL,
                                wszProcessName,
                                NULL,
                                NULL,
                                FALSE,
                                0,
                                NULL,
                                NULL,
                                &StartupInfo,
                                &ProcInfo);

CleanExit:

    if (ProcInfo.hProcess != NULL)
    {
        CloseHandle(ProcInfo.hProcess);
    }

    if (ProcInfo.hThread != NULL)
    {
        CloseHandle(ProcInfo.hThread);
    }

    LocalFree(pIntegritySid);

    if (hNewToken != NULL)
    {
        CloseHandle(hNewToken);
    }

    if (hToken != NULL)
    {
        CloseHandle(hToken);
    }

    return fRet;
}

Lokalizacje z możliwością zapisu w niskiej integralności

System Windows Vista ma określone lokalizacje plików i rejestru, które są przypisane do niskich obowiązkowych etykiet, aby umożliwić aplikacjom o niskiej integralności dostęp do zapisu. Tabela 10 zawiera te lokalizacje zapisywalne.

Tabela 10 Lokalizacje, które można zapisywać dla niskich obowiązkowych etykiet

Obniżanie obowiązkowej etykiety zasobu

Ze względu na potencjalne zagrożenia bezpieczeństwa nie zalecamy projektowania procesu o wyższej integralności w celu akceptowania danych wejściowych lub udostępniania zasobów przy użyciu procesów o niskiej integralności. Proces o niskiej integralności może próbować złośliwych zachowań. Jednak może być wymagane wykonanie tej akcji zgodnie z projektem.

Ponieważ aplikacje o niskiej integralności mogą zapisywać tylko w zasobach o niskiej integralności, należy obniżyć poziom integralności udostępnionych zasobów.

Aby obniżyć poziom integralności udostępnionych zasobów

1. Utwórz deskryptor zabezpieczeń SDDL, który definiuje niską etykietę obowiązkową.

2. Przekonwertuj ciąg SDDL na deskryptor zabezpieczeń.

3. Przypisz atrybut niskiej integralności do deskryptora zabezpieczeń.

4. Przypisz deskryptor zabezpieczeń do zasobu udostępnionego.

Poniższy przykładowy kod przedstawia ten proces.

#include <sddl.h>
#include <AccCtrl.h>
#include <Aclapi.h>

void SetLowLabelToFile()
{
 // The LABEL_SECURITY_INFORMATION SDDL SACL to be set for low integrity 
 #define LOW_INTEGRITY_SDDL_SACL_W L"S:(ML;;NW;;;LW)"
 DWORD dwErr = ERROR_SUCCESS;
 PSECURITY_DESCRIPTOR pSD = NULL;  

 PACL pSacl = NULL; // not allocated
 BOOL fSaclPresent = FALSE;
 BOOL fSaclDefaulted = FALSE;
 LPCWSTR pwszFileName = L"Sample.txt";

 if (ConvertStringSecurityDescriptorToSecurityDescriptorW(
     LOW_INTEGRITY_SDDL_SACL_W, SDDL_REVISION_1, &pSD, NULL)) 
 {
  if (GetSecurityDescriptorSacl(pSD, &fSaclPresent, &pSacl, 
     &fSaclDefaulted))
  {
   // Note that psidOwner, psidGroup, and pDacl are 
   // all NULL and set the new LABEL_SECURITY_INFORMATION
   dwErr = SetNamedSecurityInfoW((LPWSTR) pwszFileName, 
         SE_FILE_OBJECT, LABEL_SECURITY_INFORMATION, 
         NULL, NULL, NULL, pSacl);
  }
  LocalFree(pSD);
 }
}

Procesy aplikacji mogą ustawiać integralność zabezpieczanych obiektów tylko na poziomy na poziomie lub poniżej poziomu integralności procesu aplikacji.

Komunikacja między procesami o niskiej integralności i wyższej integralności

Procesy o niskiej integralności nie są całkowicie odizolowane od innych aplikacji. Mogą wchodzić w interakcje z innymi procesami. W rzeczywistości bez niektórych form współpracy aplikacje działające z małą integralnością mogą wydawać się, że użytkownik jest całkowicie uszkodzony.

Niektóre formy IPC są dostępne dla procesów o niskiej integralności do komunikowania się z procesami o wyższej integralności. Składniki w systemie Windows Vista blokują następujące typy komunikacji.

• Większość komunikatów okien i punktów zaczepienia procesów jest blokowana przez interfejs użytkownika.

• Otwieranie procesu i używanie metody CreateRemoteThread jest blokowane przez obowiązkową etykietę w obiektach procesu.

• Otwarcie sekcji pamięci udostępnionej na potrzeby dostępu do zapisu jest zablokowane.

• Użycie nazwanego obiektu utworzonego przez proces wyższej integralności na potrzeby synchronizacji jest domyślnie blokowane przez obowiązkową etykietę.

• Powiązanie z uruchomionym wystąpieniem usługi COM jest blokowane.
  Można jednak użyć innych typów komunikacji między procesem o niskiej integralności a procesem o wyższej integralności. Typy komunikacji, których można użyć, obejmują:

• Schowek (kopiowanie i wklejanie)

• Zdalne wywołanie procedury (RPC)

• Gniazda

• Komunikaty okien, że proces o wyższej integralności został jawnie dozwolony do odbierania z procesów niższej integralności przez wywołanie metody ChangeWindowMessageFilter

• Pamięć współdzielona, w której proces o wyższej integralności jawnie obniża obowiązkową etykietę w sekcji pamięci udostępnionej

  Ważne

  Jest to szczególnie niebezpieczne, a proces o wyższej integralności musi być ostrożny, aby zweryfikować wszystkie dane zapisywane w sekcji udostępnionej.

• Interfejsy COM, w których prawa aktywacji uruchamiania są ustawiane programowo przez proces wyższej integralności, aby umożliwić powiązanie od klientów o niskiej integralności

• Nazwane potoki, w których twórca jawnie ustawia obowiązkową etykietę na potoku, aby umożliwić dostęp do procesów niższej integralności

Te mechanizmy komunikacji umożliwiają procesowi niskiej integralności interakcję z innymi procesami aplikacji, takimi jak proces brokera, które zostały specjalnie zaprojektowane do akceptowania danych wejściowych lub wywołań ze źródła o niskiej integralności.

Ogólne wytyczne dotyczące projektowania interfejsów wywoływanych przez proces o niskiej integralności nigdy nie polegają na zaufaniu obiektowi wywołującego ani danym wejściowym. Broker o średniej integralności może zapewnić interfejs umożliwiający utworzenie pliku na danej ścieżce i umożliwienie aplikacji o niskiej integralności wywoływania interfejsu. Jednak w ten sposób można uruchomić aplikację z małą integralnością. Lepszy projekt jest przeznaczony dla procesu o niskiej integralności w celu wywołania interfejsu, który żąda, aby aplikacja o średniej integralności przedstawiała użytkownikowi wspólne okno dialogowe pliku, którego proces o niskiej integralności nie może prowadzić przy użyciu komunikatów okna. Dzięki temu użytkownik może przeglądać i wybierać plik do otwarcia lub tworzenia, a proces o średniej integralności wykonuje wszystkie operacje na plikach. Ten typ scenariusza Zapisz jako jest przykładem sposobu, w jaki program Internet Explorer w trybie chronionym korzysta z własnego procesu brokera do obsługi zapisywania strony internetowej gdzieś w profilu użytkownika.

Wiele funkcji aplikacji może działać poprawnie w procesie o niskiej integralności. Nie ma wspólnego zestawu narzędzi do uruchamiania aplikacji z małą integralnością. Każda aplikacja jest inna, a nie wszystkie aplikacje muszą działać z małą integralnością.