Existe-t-il un moyen d'empêcher les utilisateurs invités de fermer un certain programme ?

Pour empêcher la fermeture via le gestionnaire des tâches

Get " Explorateur de processus "et définissez les permissions pour "Guest" sur les deux programmes pour ne pas avoir les permissions "Terminate".

1. Trouvez le processus dans la liste de l'explorateur de processus et cliquez à droite sur "Propriétés".
2. Sécurité -> Permissions
3. Sélectionnez "Invité" -> Modifier.

Cela ne les empêche pas de fermer le programme normalement. Vous devrez masquer la fenêtre et l'icône de la barre d'état système à l'aide d'un programme tiers ou en modifiant la base de registre.

Pour limiter la consommation d'un utilisateur du réseau qui utilise trop de bande passante.

Cela semble être votre véritable problème.

Voir :

• D-Link DIR-600M - Configuration des règles QoS pour limiter la bande passante pour une adresse IP donnée
• Configuration du contrôle du trafic sur le routeur TP-LINK
• Comment limiter les vitesses sur mon "Linksys Wireless-G Home Router - WRT54GH" ?

La réponse de l'Explorateur de processus ne fonctionne qu'une fois, mais vous souhaitez probablement qu'elle s'applique même après le redémarrage de l'ordinateur. Pour ce faire, vous pouvez utiliser PowerShell :

Param (
    [string[]]$ProcessNames,
    [string]$DenyUsername
)

$cscode = @"
using System;
using System.Security;
using System.Security.AccessControl;
using System.Security.Principal;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

public class ProcessSecurity : NativeObjectSecurity
{
    public ProcessSecurity(SafeHandle processHandle)
        : base(false, ResourceType.KernelObject, processHandle, AccessControlSections.Access)
    {

    }

    public void AddAccessRule(ProcessAccessRule rule)
    {
        base.AddAccessRule(rule);
    }

    // this is not a full impl- it only supports writing DACL changes
    public void SaveChanges(SafeHandle processHandle)
    {
        Persist(processHandle, AccessControlSections.Access);
    }

    public override Type AccessRightType
    {
        get { return typeof(ProcessAccessRights); }
    }

    public override AccessRule AccessRuleFactory(System.Security.Principal.IdentityReference identityReference, int accessMask, bool isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AccessControlType type)
    {
        return new ProcessAccessRule(identityReference, (ProcessAccessRights)accessMask, isInherited, inheritanceFlags, propagationFlags, type);
    }

    public override Type AccessRuleType
    {
        get { return typeof(ProcessAccessRule); }
    }

    public override AuditRule AuditRuleFactory(System.Security.Principal.IdentityReference identityReference, int accessMask, bool isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AuditFlags flags)
    {
        throw new NotImplementedException();
    }

    public override Type AuditRuleType
    {
        get { throw new NotImplementedException(); }
    }
}

public class ProcessAccessRule : AccessRule
{
    public ProcessAccessRule(IdentityReference identityReference, ProcessAccessRights accessMask, bool isInherited, InheritanceFlags inheritanceFlags, PropagationFlags propagationFlags, AccessControlType type)
        : base(identityReference, (int)accessMask, isInherited, inheritanceFlags, propagationFlags, type)
    {
    }

    public ProcessAccessRights ProcessAccessRights { get { return (ProcessAccessRights)AccessMask; } }
}

[Flags]
public enum ProcessAccessRights
{
    STANDARD_RIGHTS_REQUIRED = (0x000F0000),
    DELETE = (0x00010000), // Required to delete the object. 
    READ_CONTROL = (0x00020000), // Required to read information in the security descriptor for the object, not including the information in the SACL. To read or write the SACL, you must request the ACCESS_SYSTEM_SECURITY access right. For more information, see SACL Access Right. 
    WRITE_DAC = (0x00040000), // Required to modify the DACL in the security descriptor for the object. 
    WRITE_OWNER = (0x00080000), // Required to change the owner in the security descriptor for the object. 

    PROCESS_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0xFFF, //All possible access rights for a process object.
    PROCESS_CREATE_PROCESS = (0x0080), // Required to create a process. 
    PROCESS_CREATE_THREAD = (0x0002), // Required to create a thread. 
    PROCESS_DUP_HANDLE = (0x0040), // Required to duplicate a handle using DuplicateHandle. 
    PROCESS_QUERY_INFORMATION = (0x0400), // Required to retrieve certain information about a process, such as its token, exit code, and priority class (see OpenProcessToken, GetExitCodeProcess, GetPriorityClass, and IsProcessInJob). 
    PROCESS_QUERY_LIMITED_INFORMATION = (0x1000),
    PROCESS_SET_INFORMATION = (0x0200), // Required to set certain information about a process, such as its priority class (see SetPriorityClass). 
    PROCESS_SET_QUOTA = (0x0100), // Required to set memory limits using SetProcessWorkingSetSize. 
    PROCESS_SUSPEND_RESUME = (0x0800), // Required to suspend or resume a process. 
    PROCESS_TERMINATE = (0x0001), // Required to terminate a process using TerminateProcess. 
    PROCESS_VM_OPERATION = (0x0008), // Required to perform an operation on the address space of a process (see VirtualProtectEx and WriteProcessMemory). 
    PROCESS_VM_READ = (0x0010), // Required to read memory in a process using ReadProcessMemory. 
    PROCESS_VM_WRITE = (0x0020), // Required to write to memory in a process using WriteProcessMemory. 
    SYNCHRONIZE = (0x00100000), // Required to wait for the process to terminate using the wait functions. 
}
"@

Add-Type -TypeDefinition $cscode

$ProcessNames | % {
    Get-Process -ProcessName $_ | % {
        $handle = $_.SafeHandle
        $acl = New-Object ProcessSecurity $handle
        $ident = New-Object System.Security.Principal.NTAccount $DenyUsername
        $ace = New-Object ProcessAccessRule ($ident, 'PROCESS_TERMINATE, PROCESS_SUSPEND_RESUME, WRITE_DAC', $false, 'None', 'None', 'Deny')
        $acl.AddAccessRule($ace)
        $acl.SaveChanges($handle)
    }
}

Il est basé sur cette réponse de Stack Overflow . En gros, vous lui fournissez la liste des processus à protéger et de l'utilisateur à protéger, et il modifie les ACL des processus en conséquence. Enregistrez-le comme un .ps1 (dans un endroit que l'utilisateur peut lire mais pas écrire), puis placez un fichier batch contenant quelque chose comme ceci dans le Startup de l'utilisateur :

powershell \path\to\script.ps1 ('snippingtool', 'mspaint') 'Guest' -executionpolicy bypass

Cela protège snippingtool.exe y mspaint.exe (l'outil de découpage et Paint) d'être tués par Guest.

Notez que cela doit être exécuté après ces processus commencent. Vous devrez peut-être ajouter un sleep 10 environ après le Param du script de PowerShell. Une fois qu'il est terminé, essayer de tuer ces processus avec le gestionnaire des tâches provoquera ceci :

Notez également qu'il ne fera rien d'utile si le compte avec lequel vous le testez est un administrateur, ou plus précisément a SeDebugPrivilege .

Si vous cliquez sur le X de leur fenêtre ou si vous utilisez la fonctionnalité de fermeture des applications, les processus se termineront quand même, puisque tous les processus sont libres de décider d'arrêter de fonctionner. Vous devrez peut-être masquer la zone de notification, comme décrit dans une autre réponse. De plus, puisque ces processus importants s'exécutent en tant qu'utilisateur invité, cet utilisateur est le propriétaire des objets de processus et pourra de toute façon réajuster la liste de contrôle d'accès, ou utiliser la fonction PROCESS_VM_WRITE pour gribouiller dans la mémoire des processus et les faire planter. Ces problèmes pourraient être résolus par l'ajout d'un ACE vierge de OWNER RIGHTS et en modifiant 'PROCESS_TERMINATE, PROCESS_SUSPEND_RESUME, WRITE_DAC' a 'PROCESS_ALL_ACCESS' respectivement.

Refuser l'accès au Gestionnaire de Tâches via le GPO empêcherait l'utilisateur d'utiliser le Gestionnaire de Tâches (évidemment) et constitue la solution la plus simple, mais rien ne l'empêche d'exécuter son propre programme (ou son propre logiciel). taskkill ) qui n'obéit pas à la politique du groupe. Il serait préférable que les processus que vous essayez de défendre s'exécutent sous un utilisateur différent de celui contre lequel vous essayez de vous défendre.

Bien entendu, si votre invité est prêt à se donner tout ce mal pour contourner ces diverses "protections", il se peut que vous ayez davantage un problème social qu'un problème technique.

Cela dépend vraiment de la mesure dans laquelle vous voulez verrouiller votre compte d'utilisateur invité. Il serait donc utile de disposer de plus d'informations sur ce que vous voulez que votre compte d'invité puisse faire ou ne pas faire. L'ordinateur est-il également connecté au domaine ?

Cela dit, mon opinion personnelle est que tout compte d'invité connecté au domaine ou non doit être fortement verrouillé pour s'assurer que rien de malveillant ne peut être fait en utilisant cette machine, surtout si elle se retrouve accidentellement dans de mauvaises mains. Je commence par faire ce qui suit en utilisant la stratégie de groupe.

1. Masquez complètement la zone de notification afin que votre utilisateur ne puisse accéder à aucune des applications fonctionnant en arrière-plan. Si vous avez besoin qu'ils interagissent avec NetLimiter et TeamViewer, ils peuvent toujours les lancer depuis le menu de démarrage.

   L'élément spécifique de GP dont vous avez besoin se trouve dans Configuration de l'utilisateur > Modèles d'administration > Menu Démarrer et barre des tâches > Masquer la zone de notification.

2. L'accès au gestionnaire des tâches a été désactivé, ce qui devrait les empêcher de mettre fin au processus.

   Configuration utilisateur > Modèles d'administration > Système > Supprimer le gestionnaire de tâches

3. Je crois que NetLimiter a la possibilité de définir des autorisations pour différents utilisateurs. Explorez-les et voyez si vous pouvez supprimer la capacité du compte utilisateur à contrôler l'application.

C'est un bon début qui devrait limiter la plupart des utilisateurs ; si vos utilisateurs sont un peu plus avancés, vous devrez peut-être définir des stratégies de groupe plus complètes.

Voici un bon guide pour utiliser GP afin de limiter les polices à des utilisateurs spécifiques si vous en avez besoin. http://www.sevenforums.com/tutorials/151415-group-policy-apply-specific-user-group.html