Conception d’applications à exécuter à un niveau d’intégrité faible

Article
07/05/2007

Un moyen simple d’exécuter un processus d’application à un niveau d’intégrité faible consiste à définir le niveau d’intégrité du fichier programme exécutable sur une faible intégrité. Lorsque ce fichier image est lancé, le processus d’application démarre avec un faible niveau d’intégrité. Par exemple, supposons que nous voulons exécuter l’application Calculatrice Windows dans un processus d’intégrité faible.

Pour exécuter calc.exe à faible intégrité

Effectuez une copie de c:\Windows\system32\calc.exe dans un dossier temporaire.
Utilisez le programme icacls pour définir le niveau d’intégrité du fichier temporaire, lowcalc.exe, sur une faible intégrité à l’aide de la commande icacls :

icacls lowcalc.exe /setintegritylevel Low
Exécutez la version à faible intégrité de calc.exe.

L’image suivante montre les étapes d’exécution de la calculatrice Windows dans un processus de faible intégrité.

Figure 9 Lancement de la calculatrice Windows à faible intégrité

Vous pouvez utiliser Process Explorer pour vérifier que le fichier image, lowcalc.exe, est en cours d’exécution avec une intégrité faible. La colonne Niveau d’intégrité se trouve sur le côté droit de l’image.

Figure 10 Processus de calculatrice faible

Tous les programmes d’application ne s’exécutent pas correctement dans un processus à faible intégrité. Un processus à faible intégrité n’a pas accès en écriture à la plupart des zones situées sous la zone de profil local de l’utilisateur du système de fichiers ou le Registre sous HKCU. L’impossibilité pour un processus à faible intégrité d’obtenir un accès en écriture au profil utilisateur est une bonne chose si le programme est un logiciel malveillant indésirable. Toutefois, pour les applications telles que les Explorer Internet en mode protégé, une refonte peut être nécessaire pour que toutes les fonctionnalités de l’application se comportent correctement.

Utilisez des outils utiles tels que Process Monitor à partir de Sysinternals.com pour avoir une idée des ressources de fichier et de Registre qu’une application utilise actuellement pour l’accès en écriture qui échouent en cas d’exécution à faible intégrité.

Bien qu’il soit possible de modifier une application pour qu’elle s’exécute entièrement à faible intégrité, certaines fonctionnalités de l’application peuvent fonctionner correctement uniquement lorsqu’elles sont implémentées dans un processus d’intégrité moyenne. Une application qui s’exécute à faible intégrité peut avoir une partie de l’application dans un processus de faible intégrité, par exemple pour gérer des données non approuvées à partir d’Internet. Une autre partie de l’application peut être implémentée dans un processus « broker » d’intégrité moyenne pour gérer un petit ensemble d’actions initiées par l’utilisateur. La communication entre les processus de faible intégrité et d’intégrité moyenne dans l’application peut être gérée à l’aide de différents mécanismes IPC. La partie d’intégrité moyenne de l’application doit supposer que toutes les données et le code du processus de faible intégrité ne sont pas fiables.

Le mode internet protégé Explorer est une application qui est repensée pour s’exécuter dans un processus de faible intégrité. Pour plus d’informations sur les Explorer Internet en mode protégé, consultez Comprendre et travailler en mode protégé Internet Explorer (https://go.microsoft.com/fwlink/?LinkId=90931).

Les rubriques main pour concevoir une application à exécuter à faible intégrité sont les suivantes :

Démarrage d’un processus enfant à faible intégrité
Emplacements pouvant être écrits pour les applications à faible intégrité
Communication entre les processus de faible intégrité et de niveau supérieur

Démarrage d’un processus à faible intégrité

Par défaut, les processus enfants héritent du niveau d’intégrité de leur processus parent. Pour démarrer un processus à faible intégrité, vous devez démarrer un nouveau processus enfant avec un jeton d’accès à faible intégrité à l’aide de la fonction CreateProcessAsUser. Pour démarrer un processus à faible intégrité à partir d’un processus d’intégrité moyenne, vous devez démarrer le nouveau processus explicitement en tant que faible intégrité.

Pour démarrer un processus de faible intégrité

Dupliquez le handle du processus actuel, qui est au niveau d’intégrité moyen.
Utilisez SetTokenInformation pour définir le niveau d’intégrité dans le jeton d’accès sur Faible.
Utilisez CreateProcessAsUser pour créer un processus à l’aide du handle du jeton d’accès à faible intégrité.

CreateProcessAsUser met à jour le descripteur de sécurité dans le nouveau processus enfant et le descripteur de sécurité du jeton d’accès pour qu’il corresponde au niveau d’intégrité du jeton d’accès à faible intégrité.

L’exemple de code suivant illustre ce processus.

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;
}

Emplacements pouvant être écrits à faible intégrité

Windows Vista a des emplacements de fichiers et de Registre spécifiques auxquels sont attribuées des étiquettes obligatoires faibles pour autoriser l’accès en écriture aux applications de faible intégrité. Le tableau 10 présente ces emplacements pouvant être écrits.

Tableau 10 Emplacements pouvant être écrits pour les étiquettes obligatoires faibles

Emplacement	Zone accessible en écriture
Registre	Les processus à faible intégrité peuvent écrire dans et créer des sous-clés sous HKEY_CURRENT_USER\Software\AppDataLow
Système de fichiers	Les processus à faible intégrité peuvent écrire et créer des sous-dossiers sous %USER PROFILE%\AppData\LocalLow

Réduction d’une étiquette obligatoire de ressource

En raison des risques de sécurité potentiels, nous vous déconseillons de concevoir un processus à intégrité supérieure pour accepter des entrées ou partager des ressources avec des processus à faible intégrité. Le processus de faible intégrité peut tenter un comportement malveillant. Toutefois, vous devrez peut-être effectuer cette action par conception.

Notes

Les applications qui acceptent l’entrée de ou partagent des ressources avec des processus à faible intégrité doivent supposer que les données que les processus d’intégrité inférieure fournissent ne peuvent pas être approuvées et doivent ensuite effectuer la validation appropriée. Par exemple, le mode protégé Internet Explorer affiche la boîte de dialogue Enregistrer sous à partir du processus Internet Explorer User Broker. Cela permet aux utilisateurs de confirmer qu’ils souhaitent enregistrer un fichier à l’aide d’un processus qui s’exécute avec des droits plus élevés que les Explorer Internet en mode protégé.

Étant donné que les applications à faible intégrité peuvent écrire uniquement dans des ressources à faible intégrité, vous devez réduire le niveau d’intégrité des ressources partagées.

Pour réduire le niveau d’intégrité des ressources partagées

Créez un descripteur de sécurité SDDL qui définit une étiquette obligatoire faible.
Convertissez la chaîne SDDL en descripteur de sécurité.
Attribuez l’attribut de faible intégrité au descripteur de sécurité.
Affectez le descripteur de sécurité à la ressource partagée.

L’exemple de code suivant illustre ce processus.

#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);
 }
}

Les processus d’application peuvent définir l’intégrité des objets sécurisables uniquement à des niveaux inférieurs ou égal au niveau d’intégrité du processus d’application.

Communication entre les processus de faible intégrité et d’intégrité supérieure

Les processus de faible intégrité ne sont pas complètement isolés des autres applications. Ils peuvent interagir avec d’autres processus. En fait, sans certaines formes de collaboration, les applications s’exécutant à faible intégrité peuvent sembler complètement rompues à l’utilisateur.

Certaines formes d’IPC sont disponibles pour les processus à faible intégrité afin de communiquer avec les processus à intégrité supérieure. Les composants de Windows Vista bloquent les types de communication suivants.

La plupart des messages de fenêtre et des hooks de processus sont bloqués par UIPI.
L’ouverture d’un processus et l’utilisation de CreateRemoteThread sont bloquées par l’étiquette obligatoire sur les objets de processus.
L’ouverture d’une section de mémoire partagée pour l’accès en écriture est bloquée.
L’utilisation d’un objet nommé créé par un processus d’intégrité supérieur pour la synchronisation est bloquée par l’étiquette obligatoire par défaut.
La liaison à un instance en cours d’exécution d’un service COM est bloquée.
Toutefois, vous pouvez utiliser d’autres types de communication entre un processus à faible intégrité et un processus à intégrité supérieure. Les types de communication que vous pouvez utiliser sont les suivants :
Presse-papiers (copier-coller)
Appel de procédure distante (RPC)
Sockets
Messages de fenêtre que le processus à intégrité supérieure a été explicitement autorisé à recevoir à partir de processus à intégrité inférieure en appelant ChangeWindowMessageFilter
Mémoire partagée, où le processus d’intégrité supérieure réduit explicitement l’étiquette obligatoire dans la section mémoire partagée

Important

Cela est particulièrement dangereux, et le processus d’intégrité supérieure doit veiller à valider toutes les données écrites dans la section partagée.
Interfaces COM, où les droits d’activation de lancement sont définis par programme par le processus d’intégrité supérieure pour permettre la liaison à partir de clients à faible intégrité
Canaux nommés, où le créateur définit explicitement l’étiquette obligatoire sur le canal pour autoriser l’accès aux processus à faible intégrité

Ces mécanismes de communication permettent au processus de faible intégrité d’interagir avec d’autres processus d’application, tels qu’un processus broker, qui sont spécifiquement conçus pour accepter des entrées ou des appels provenant de la source à faible intégrité.

Une recommandation générale pour la conception d’interfaces qu’un processus à faible intégrité appellera est de ne jamais faire confiance à l’appelant ou aux données d’entrée. Un répartiteur d’intégrité moyenne peut fournir une interface pour créer un fichier en fonction d’un chemin d’accès et pour permettre à une application à faible intégrité d’appeler l’interface. Toutefois, cela va à l’échec de l’objectif de l’exécution d’une application à faible intégrité. Une meilleure conception consiste à appeler une interface qui demande à l’application d’intégrité moyenne de présenter une boîte de dialogue de fichier commune à l’utilisateur, ce que le processus de faible intégrité ne peut pas gérer à l’aide de messages de fenêtre. De cette façon, vous laissez l’utilisateur parcourir et sélectionner le fichier à ouvrir ou à créer, et le processus d’intégrité moyenne effectue toutes les opérations de fichier. Ce type de scénario d’enregistrement sous est un exemple de la façon dont les Explorer Internet en mode protégé utilisent son propre processus broker pour gérer l’enregistrement d’une page web quelque part dans le profil de l’utilisateur.

De nombreuses fonctionnalités d’application peuvent s’exécuter correctement dans un processus à faible intégrité. Il n’existe aucun ensemble commun d’outils pour exécuter des applications à faible intégrité. Chaque application est différente, et toutes les applications ne doivent pas s’exécuter à faible intégrité.

Partager via