Recursos de Função JEAJEA Role Capabilities

Aplica-se a: Windows PowerShell 5.0Applies to: Windows PowerShell 5.0

Ao criar um ponto de extremidade JEA, é necessário definir um ou mais "recursos de função" que descrevem o que alguém pode fazer em uma sessão JEA.When creating a JEA endpoint, you will need to define one or more "role capabilities" which describe what someone can do in a JEA session. Uma capacidade de função é um arquivo de dados do PowerShell com a extensão .psrc que lista todos os cmdlets, as funções, os provedores e os programas externos que devem ser disponibilizados para usuários que estão se conectando.A role capability is a PowerShell data file with the .psrc extension that lists all the cmdlets, functions, providers, and external programs that should be made available to connecting users.

Este tópico descreve como criar um arquivo da capacidade de função do PowerShell para seus usuários JEA.This topic describes how to create a PowerShell role capability file for your JEA users.

Determinar quais comandos permitirDetermine which commands to allow

A primeira etapa ao criar um arquivo de capacidade de função é considerar o que os usuários que recebem a função precisarão acessar.The first step when creating a role capability file is to consider what the users who are assigned the role will need access to. Esse processo de coleta de requisitos pode levar algum tempo, mas é um processo muito importante.This requirements gathering process can take a while, but it is a very important process. Conceder aos usuários acesso a poucos cmdlets e funções pode impedi-los de cumprir suas tarefas.Giving users access to too few cmdlets and functions can prevent them from getting their job done. Permitir o acesso a muitos cmdlets e funções pode resultar em usuários fazendo mais do que você pretendia com os privilégios implícitos de administrador, enfraquecendo a sua postura de segurança.Allowing access to too many cmdlets and functions can lead to users doing more than you intended with their implicit admin privileges, weakening your security stance.

A maneira como você avança nesse processo dependerá da sua organização e dos objetivos, no entanto, as dicas a seguir podem ajudar a garantir que você esteja no caminho certo.How you go about this process will depend on your organization and goals, however the following tips can help ensure you're on the right path.

  1. Identificar os comandos que os usuários estão usando para executar seus trabalhos.Identify the commands users are using to get their jobs done. Isso pode envolver pesquisar a equipe de TI, verificar scripts de automação ou analisar transcrições ou logs de sessão do PowerShell.This may involve surveying IT staff, checking automation scripts, or analyzing PowerShell session transcripts or logs.
  2. Atualizar o uso de ferramentas de linha de comando para equivalentes do PowerShell, sempre que possível, para uma melhor experiência de auditoria e de personalização de JEA.Update use of command line tools to PowerShell equivalents, where possible, for the best auditing and JEA customization experience. Os programas externos não podem ser restritos de forma tão granular como os cmdlets e funções nativas do PowerShell no JEA.External programs cannot be constrained as granularly as native PowerShell cmdlets and functions in JEA.
  3. Restringir o escopo dos cmdlets se necessário, para permitir apenas parâmetros ou valores de parâmetro específicos.Restrict the scope of the cmdlets if necessary to only allow specific parameters or parameter values. Isso é particularmente importante se os usuários devem ser capazes de gerenciar apenas uma parte de um sistema.This is particularly important if users should only be able to manage part of a system.
  4. Criar funções personalizadas para substituir comandos complexos ou comandos que são difíceis de restringir no JEA.Create custom functions to replace complex commands or commands which are difficult to constrain in JEA. Uma função simples que encapsula um comando complexo ou que aplica lógica de validação adicional pode oferecer controle adicional para administradores e simplicidade para usuários finais.A simple function that wraps a complex command or applies additional validation logic can offer additional control for admins and end-user simplicity.
  5. Testar a lista de escopo de comandos permitidos com seus usuários e/ou serviços de automação e ajustar conforme necessário.Test the scoped list of allowable commands with your users and/or automation services and adjust as necessary.

É importante lembrar que os comandos em uma sessão JEA são geralmente executados com privilégios de administrador (ou elevados de outra maneira).It is important to remember that commands in a JEA session are often run with admin (or otherwise elevated) privileges. A seleção cuidadosa de comandos disponíveis é importante para garantir que o ponto de extremidade JEA não permita que o usuário que está se conectando eleve suas permissões.Careful selection of available commands is important to ensure the JEA endpoint does not allow the connecting user to elevate their permissions. Abaixo estão alguns exemplos de comandos que podem ser usados maliciosamente se forem permitidos em um estado sem restrições.Below are some examples of commands that can be used maliciously if allowed in an unconstrained state. Observe que essa não é uma lista completa e só deve ser usada como um ponto de partida preventivo.Note that this is not an exhaustive list and should only be used as a cautionary starting point.

Exemplos de comandos potencialmente perigososExamples of potentially dangerous commands

RiscoRisk ExemploExample Comandos relacionadosRelated commands
Concedendo privilégios de administrador ao usuário que está se conectando, para ignorar o JEAGranting the connecting user admin privileges to bypass JEA Add-LocalGroupMember -Member 'CONTOSO\jdoe' -Group 'Administrators' Add-ADGroupMember, Add-LocalGroupMember, net.exe, dsadd.exeAdd-ADGroupMember, Add-LocalGroupMember, net.exe, dsadd.exe
Execução de código arbitrário, como malware, explorações ou scripts personalizados para ignorar proteçõesRunning arbitrary code, such as malware, exploits, or custom scripts to bypass protections Start-Process -FilePath '\\san\share\malware.exe' Start-Process, New-Service, Invoke-Item, Invoke-WmiMethod, Invoke-CimMethod, Invoke-Expression, Invoke-Command, New-ScheduledTask, Register-ScheduledJobStart-Process, New-Service, Invoke-Item, Invoke-WmiMethod, Invoke-CimMethod, Invoke-Expression, Invoke-Command, New-ScheduledTask, Register-ScheduledJob

Criar um arquivo de capacidade de funçãoCreate a role capability file

Você pode criar um novo arquivo de capacidade de função do PowerShell com o cmdlet New-PSRoleCapabilityFile.You can create a new PowerShell role capability file with the New-PSRoleCapabilityFile cmdlet.

New-PSRoleCapabilityFile -Path .\MyFirstJEARole.psrc

O arquivo de capacidade de função resultante pode ser aberto em um editor de texto e modificado para permitir os comandos desejados para a função.The resulting role capability file can be opened in a text editor and modified to allow the desired commands for the role. A documentação de ajuda do PowerShell contém vários exemplos de como você pode configurar o arquivo.The PowerShell help documentation contains several examples of how you can configure the file.

Permitir cmdlets e funções do PowerShellAllowing PowerShell cmdlets and functions

Para autorizar usuários a executar funções ou cmdlets do PowerShell, adicione o nome do cmdlet ou da função nos campos VisbibleCmdlets ou VisibleFunctions.To authorize users to run PowerShell cmdlets or functions, add the cmdlet or function name to the VisbibleCmdlets or VisibleFunctions fields. Se você não tiver certeza se um comando é um cmdlet ou uma função, você poderá executar Get-Command <name> e verificar a propriedade "CommandType" na saída.If you aren't sure whether a command is a cmdlet or function, you can run Get-Command <name> and check the "CommandType" property in the output.

VisibleCmdlets = 'Restart-Computer', 'Get-NetIPAddress'

Às vezes, o escopo de um cmdlet ou de uma função específica é muito amplo para as necessidades dos usuários.Sometimes the scope of a specific cmdlet or function is too broad for your users' needs. Um administrador de DNS, por exemplo, provavelmente só precisa de acesso para reiniciar o serviço DNS.A DNS admin, for example, probably only needs access to restart the DNS service. Em um ambiente de multilocatário em que os locatários recebem acesso a ferramentas de gerenciamento de autoatendimento, os locatários devem ser limitados ao gerenciamento com seus próprios recursos.In a multi-tenant environment where tenants are granted access to self-service management tools, tenants should be limited to managing with their own resources. Nesses casos, você pode restringir quais parâmetros são expostos do cmdlet ou da função.For these cases, you can restrict which parameters are exposed from the cmdlet or function.


VisibleCmdlets = @{ Name = 'Restart-Computer'; Parameters = @{ Name = 'Name' }}

Em cenários mais avançados, também pode ser necessário restringir os valores que alguém pode fornecer a esses parâmetros.In more advanced scenarios, you may also need to restrict which values someone can supply to these parameters. Os recursos de função permitem que seja definido um conjunto de valores permitidos ou um padrão de expressão regular que é avaliado para determinar se uma determinada entrada é permitida.Role capabilities let you define a set of allowed values or a regular expression pattern that is evaluated to determine if a given input is allowed.

VisibleCmdlets = @{ Name = 'Restart-Service'; Parameters = @{ Name = 'Name'; ValidateSet = 'Dns', 'Spooler' }},
                 @{ Name = 'Start-Website'; Parameters = @{ Name = 'Name'; ValidatePattern = 'HR_*' }}

Observação

Os parâmetros comuns do PowerShell são sempre permitidos, mesmo que você restrinja os parâmetros disponíveis.The common PowerShell parameters are always allowed, even if you restrict the available parameters. Você não deve listá-los explicitamente no campo Parâmetros.You should not explicitly list them in the Parameters field.

A tabela a seguir descreve as várias maneiras que podem ser usadas para personalizar um cmdlet ou função visível.The table below describes the various ways you can customize a visible cmdlet or function. Você pode misturar e combinar qualquer item abaixo no campo VisibleCmdlets.You can mix and match any of the below in the VisibleCmdlets field.

ExemploExample Caso de usoUse case
'My-Func' ou @{ Name = 'My-Func' }'My-Func' or @{ Name = 'My-Func' } Permite que o usuário execute My-Func sem quaisquer restrições nos parâmetros.Allows the user to run My-Func without any restrictions on the parameters.
'MyModule\My-Func' Permite que o usuário execute My-Func do módulo MyModule sem quaisquer restrições nos parâmetros.Allows the user to run My-Func from the module MyModule without any restrictions on the parameters.
'My-*' Permite que o usuário execute qualquer cmdlet ou função com o verbo My.Allows the user to run any cmdlet or function with the verb My.
'*-Func' Permite que o usuário execute qualquer cmdlet ou função com o substantivo Func.Allows the user to run any cmdlet or function with the noun Func.
@{ Name = 'My-Func'; Parameters = @{ Name = 'Param1'}, @{ Name = 'Param2' }} Permite que o usuário execute My-Func com os parâmetros Param1 e/ou Param2.Allows the user to run My-Func with the Param1 and/or Param2 parameters. Qualquer valor pode ser fornecido para os parâmetros.Any value can be supplied to the parameters.
@{ Name = 'My-Func'; Parameters = @{ Name = 'Param1'; ValidateSet = 'Value1', 'Value2' }} Permite que o usuário execute My-Func com o parâmetro Param1.Allows the user to run My-Func with the Param1 parameter. Somente "Value1" e "Value2" podem ser fornecidos ao parâmetro.Only "Value1" and "Value2" can be supplied to the parameter.
@{ Name = 'My-Func'; Parameters = @{ Name = 'Param1'; ValidatePattern = 'contoso.*' }} Permite que o usuário execute My-Func com o parâmetro Param1.Allows the user to run My-Func with the Param1 parameter. Qualquer valor começando com "contoso" pode ser fornecido ao parâmetro.Any value starting with "contoso" can be supplied to the parameter.

Aviso

Como práticas recomendadas de segurança, não é recomendável usar curingas ao definir cmdlets ou funções visíveis.For best security practices, it is not recommended to use wildcards when defining visible cmdlets or functions. Em vez disso, você deve listar explicitamente cada comando confiável para garantir que outros comandos que compartilham o mesmo esquema de nomenclatura não sejam acidentalmente autorizados.Instead, you should explicitly list each trusted command to ensure no other commands that share the same naming scheme are unintentionally authorized.

Você não pode aplicar um ValidatePattern e ValidateSet no mesmo cmdlet ou função.You cannot apply both a ValidatePattern and ValidateSet to the same cmdlet or function.

Se isso acontecer, o ValidatePattern substituirá o ValidateSet.If you do, the ValidatePattern will override the ValidateSet.

Para obter mais informações sobre ValidatePattern, dê uma olhada nessa postagem Hey, Scripting Guy! e no conteúdo de referência Expressões regulares do PowerShell.For more information about ValidatePattern, check out this Hey, Scripting Guy! post and the PowerShell Regular Expressions reference content.

Permitindo comandos externos e scripts do PowerShellAllowing external commands and PowerShell scripts

Para permitir que os usuários executem scripts do PowerShell (.ps1) e arquivos executáveis em uma sessão JEA, é necessário adicionar o caminho completo para cada programa no campo VisibleExternalCommands.To allow users to run executables and PowerShell scripts (.ps1) in a JEA session, you have to add the full path to each program in the VisibleExternalCommands field.

VisibleExternalCommands = 'C:\Windows\System32\whoami.exe', 'C:\Program Files\Contoso\Scripts\UpdateITSoftware.ps1'

É recomendável, sempre que possível, usar cmdlets ou funções do PowerShell equivalentes às dos arquivos externos executáveis que você autorizar, pois você tem controle sobre quais parâmetros são permitidos com cmdlets ou funções do PowerShell.It is advised, where possible, to use PowerShell cmdlet/function equivalents of any external executables you authorize since you have control over which parameters are allowed with PowerShell cmdlets/functions.

Muitos executáveis permitem que você leia o estado atual e, em seguida, altere-o simplesmente fornecendo parâmetros diferentes.Many executables allow you to both read the current state and then change it just by providing different parameters.

Por exemplo, considere a função de um administrador de servidor de arquivo que deseja verificar quais compartilhamentos de rede são hospedados pelo computador local.For example, consider the role of a file server admin who wants to check which network shares are hosted by the local machine. Uma maneira de verificar é usar net share.One way to check is to use net share. No entanto, permitir o net.exe é muito perigoso, pois o administrador poderia facilmente usar o comando para obter privilégios de administrador com net group Administrators unprivilegedjeauser /add.However, allowing net.exe is very dangerous becuase the admin could just as easily use the command to gain admin privileges with net group Administrators unprivilegedjeauser /add. Uma abordagem melhor é permitir o Get-SmbShare que alcança o mesmo resultado, mas tem um escopo muito mais limitado.A better approach is to allow Get-SmbShare which achieves the same result but has a much more limited scope.

Ao disponibilizar comandos externos aos usuários em uma sessão JEA, sempre especifique o caminho completo para o executável para garantir que um programa nomeado da mesma forma (e potencialmente mal-intencionado) colocado em outro lugar no sistema não seja executado em vez disso.When making external commands available to users in a JEA session, always specify the complete path to the executable to ensure a similarly named (and potentially malicous) program placed elsewhere on the system does not get executed instead.

Permitindo acesso aos provedores do PowerShellAllowing access to PowerShell providers

Por padrão, nenhum provedor de PowerShell está disponível em sessões JEA.By default, no PowerShell providers are available in JEA sessions.

Isso é, principalmente, para reduzir o risco da revelação de informações confidenciais e definições de configuração ao usuário que está se conectando.This is primarily to reduce the risk of sensitive information and configuration settings being disclosed to the connecting user.

Quando necessário, você pode permitir acesso aos provedores do PowerShell usando o comando VisibleProviders.When necessary, you can allow access to the PowerShell providers using the VisibleProviders command. Para obter uma lista completa dos provedores, execute o Get-PSProvider.For a full list of providers, run Get-PSProvider.

VisibleProviders = 'Registry'

Para tarefas simples que exigem acesso ao sistema de arquivos, Registro, repositório de certificados ou outros provedores confidenciais, você também pode considerar escrever uma função personalizada que funcione com o provedor em nome do usuário.For simple tasks that require access to the file system, registry, certificate store, or other sensitive providers, you can also consider writing a custom function that works with the provider on the user's behalf. Funções, cmdlets e programas externos que estão disponíveis em uma sessão JEA não estão sujeitos às mesmas restrições que o JEA. Eles podem acessar qualquer provedor por padrão.Functions, cmdlets, and external programs that are available in a JEA session are not subject to the same constraints as JEA -- they can access any provider by default. Considere também usar a unidade de usuário quando for necessário copiar arquivos para/de um ponto de extremidade JEA.Also consider using the user drive when copying files to/from a JEA endpoint is required.

Criando funções personalizadasCreating custom functions

Você pode criar funções personalizadas em um arquivo de capacidade de função para simplificar tarefas complexas para os seus usuários finais.You can author custom functions in a role capability file to simplify complex tasks for your end users. As funções personalizadas também são úteis quando você precisar de lógica de validação avançada para valores de parâmetro de cmdlet.Custom functions are also useful when you require advanced validation logic for cmdlet parameter values. É possível escrever funções simples no campo FunctionDefinitions:You can write simple functions in the FunctionDefinitions field:

VisibleFunctions = 'Get-TopProcess'

FunctionDefinitions = @{
    Name = 'Get-TopProcess'

    ScriptBlock = {
        param($Count = 10)

        Get-Process | Sort-Object -Property CPU -Descending | Microsoft.PowerShell.Utility\Select-Object -First $Count
    }
}

Importante

Não se esqueça de adicionar o nome de suas funções personalizadas no campo VisibleFunctions para que elas possam ser executadas pelos usuários JEA.Don't forget to add the name of your custom functions to the VisibleFunctions field so they can be run by the JEA users.

O corpo (bloco de script) de funções personalizadas é executado no modo de idioma padrão do sistema e não está sujeito a restrições de linguagem do JEA.The body (script block) of custom functions runs in the default language mode for the system and is not subject to JEA's language constraints. Isso significa que as funções podem acessar o sistema de arquivos e o Registro e executar comandos que não foram tornados visíveis no arquivo de capacidade de função.This means that functions can access the file system and registry, and run commands that were not made visible in the role capability file. Tome cuidado para evitar a permissão de execução de códigos arbitrários ao usar parâmetros e evitar redirecionar a entrada do usuário diretamente em cmdlets como o Invoke-Expression.Take care to avoid allowing arbitrary code to be run when using parameters and avoid piping user input directly into cmdlets like Invoke-Expression.

No exemplo acima, você observará que o FQMN (nome do módulo totalmente qualificado) Microsoft.PowerShell.Utility\Select-Object foi usado em vez da abreviação Select-Object.In the above example, you will notice that the fully qualified module name (FQMN) Microsoft.PowerShell.Utility\Select-Object was used instead of the shorthand Select-Object. As funções definidas em arquivos de capacidade de função ainda estão sujeitas ao escopo das sessões JEA, que inclui as funções de proxy que o JEA cria para restringir os comandos existentes.Functions defined in role capability files are still subject to the scope of JEA sessions, which includes the proxy functions JEA creates to constrain existing commands.

O Select-Object é um cmdlet padrão, restrito em todas as sessões JEA que não permite que você selecione propriedades arbitrárias em objetos.Select-Object is a default, constrained cmdlet in all JEA sessions that doesn't allow you to select arbitrary properties on objects. Para usar o Select-Object irrestrito nas funções, você deve solicitar explicitamente a implementação completa, especificando o FQMN.To use the unconstrained Select-Object in functions, you must explicitly request the full implementation by specifying the FQMN. Qualquer cmdlet restrito em uma sessão JEA exibirá o mesmo comportamento ao ser invocado de uma função, em acordo com a precedência de comando do PowerShell.Any constrained cmdlet in a JEA session will exhibit the same behavior when invoked from a function, in line with PowerShell's command precedence.

Se você estiver escrevendo muitas funções personalizadas, poderá ser mais fácil colocá-las em um Módulo de Script do PowerShell.If you are writing a lot of custom functions, it may be easier to put them in a PowerShell Script Module. Em seguida, você pode tornar essas funções visíveis na sessão JEA, usando o campo VisibleFunctions, assim como faria com módulos internos e de terceiros.You can then make those functions visible in the JEA session using the VisibleFunctions field like you would with built-in and third party modules.

Colocar recursos de função em um móduloPlace role capabilities in a module

Para que o PowerShell localize um arquivo de capacidade de função, ele deve ser armazenado em uma pasta "RoleCapabilities" em um módulo do PowerShell.In order for PowerShell to find a role capability file, it must be stored in a "RoleCapabilities" folder in a PowerShell module. O módulo pode ser armazenado em qualquer pasta incluída na variável de ambiente $env:PSModulePath, porém você não deve colocá-lo na System32 (reservada para módulos internos) ou uma pasta em que os usuários não confiáveis que estejam se conectando poderiam modificar os arquivos.The module can be stored in any folder included in the $env:PSModulePath environment variable, however you should not place it in System32 (reserved for built-in modules) or a folder where the untrusted, connecting users could modify the files. Abaixo está um exemplo de criação de um módulo de script do PowerShell básico chamado ContosoJEA no caminho "Arquivos de Programas".Below is an example of creating a basic PowerShell script module called ContosoJEA in the "Program Files" path.

# Create a folder for the module
$modulePath = Join-Path $env:ProgramFiles "WindowsPowerShell\Modules\ContosoJEA"
New-Item -ItemType Directory -Path $modulePath

# Create an empty script module and module manifest. At least one file in the module folder must have the same name as the folder itself.
New-Item -ItemType File -Path (Join-Path $modulePath "ContosoJEAFunctions.psm1")
New-ModuleManifest -Path (Join-Path $modulePath "ContosoJEA.psd1") -RootModule "ContosoJEAFunctions.psm1"

# Create the RoleCapabilities folder and copy in the PSRC file
$rcFolder = Join-Path $modulePath "RoleCapabilities"
New-Item -ItemType Directory $rcFolder
Copy-Item -Path .\MyFirstJEARole.psrc -Destination $rcFolder

Consulte Noções básicas sobre um Módulo do PowerShell para obter mais informações sobre módulos do PowerShell, manifestos de módulo e sobre a variável de ambiente PSModulePath.See Understanding a PowerShell Module for more information about PowerShell modules, module manifests, and the PSModulePath environment variable.

Atualizando recursos de funçãoUpdating role capabilities

Você pode atualizar um arquivo de capacidade de função a qualquer momento, bastando salvar as alterações no arquivo de capacidade de função.You can update a role capability file at any time by simply saving changes to the role capability file. Qualquer nova sessão JEA iniciada depois que a capacidade de função foi atualizado refletirá os recursos revisados.Any new JEA sessions started after the role capability has been updated will reflect the revised capabilities.

É por isso que é tão importante controlar o acesso à pasta de recursos de função.This is why controlling access to the role capabilities folder is so important. Apenas administradores altamente confiáveis devem ser capazes de alterar os arquivos de capacidade de função.Only highly trusted administrators should be able to change role capability files. Se um usuário não confiável puder alterar os arquivos de capacidade de função, poderá facilmente conceder a si próprio o acesso aos cmdlets que permitem que ele eleve seus privilégios.If an untrusted user can change role capability files, they can easily give themselves access to cmdlets which allow them to elevate their privileges.

Para os administradores que desejam bloquear o acesso às capacidades de função, verifique se a Sistema Local tem acesso de leitura aos arquivos de capacidade de função e aos módulos nesses arquivos.For administrators looking to lock down access to the role capabilities, ensure Local System has read access to the role capability files and containing modules.

Como os recursos de função são mescladosHow role capabilities are merged

Os usuários podem ter acesso a vários recursos de função quando ingressam em uma sessão JEA, dependendo dos mapeamentos de função no arquivo de configuração de sessão.Users can be granted access to multiple role capabilities when they enter a JEA session depending on the role mappings in the session configuration file. Quando isso acontece, o JEA tenta conceder ao usuário o conjunto mais permissivo de comandos, permitido por qualquer uma das funções.When this happens, JEA tries to give the user the most permissive set of commands allowed by any of the roles.

VisibleCmdlets e VisibleFunctionsVisibleCmdlets and VisibleFunctions

A lógica mais complexa de mesclagem afeta cmdlets e funções, que podem ter seus parâmetros e valores de parâmetro limitados no JEA.The most complex merge logic affects cmdlets and functions, which can have their parameters and parameter values limited in JEA.

As regras são as seguintes:The rules are as follows:

  1. Se um cmdlet só for visível em uma função, será visível para o usuário com qualquer restrição de parâmetro aplicável.If a cmdlet is only made visible in one role, it will be visible to the user with any applicable parameter constraints.
  2. Se um cmdlet se torna visível em mais de uma função e cada função tem as mesmas restrições sobre o cmdlet, o cmdlet será visível para o usuário com essas restrições.If a cmdlet is made visible in more than one role, and each role has the same constraints on the cmdlet, the cmdlet will be visible to the user with those constraints.
  3. Se um cmdlet se torna visível em mais de uma função e cada função permite um conjunto diferente de parâmetros, o cmdlet e todos os parâmetros definidos em cada função serão visíveis ao usuário.If a cmdlet is made visible in more than one role, and each role allows a different set of parameters, the cmdlet and all of the parameters defined across every role will be visible to the user. Se uma função não tem restrições nos parâmetros, todos os parâmetros serão permitidos.If one role doesn't have constraints on the parameters, all parameters will be allowed.
  4. Se uma função define um conjunto de validação ou padrão de validação para um parâmetro de cmdlet e a outra função permite o parâmetro, mas não restringe os valores do parâmetro, o conjunto ou padrão de validação serão ignorados.If one role defines a validate set or validate pattern for a cmdlet parameter, and the other role allows the parameter but does not constrain the parameter values, the validate set or pattern will be ignored.
  5. Se um conjunto de validação for definido para o mesmo parâmetro de cmdlet em mais de uma função, todos os valores de todos os conjuntos de validação serão permitidos.If a validate set is defined for the same cmdlet parameter in more than one role, all values from all validate sets will be allowed.
  6. Se um padrão de validação for definido para o mesmo parâmetro de cmdlet em mais de uma função, qualquer valor que corresponde a qualquer dos padrões será permitido.If a validate pattern is defined for the same cmdlet parameter in more than one role, any values that match any of the patterns will be allowed.
  7. Se um conjunto de validação for definido em uma ou mais funções e um padrão de validação for definido em outra função para o mesmo parâmetro de cmdlet, o conjunto de validação será ignorado e a regra (6) se aplica aos padrões de validação restantes.If a validate set is defined in one or more roles, and a validate pattern is defined in another role for the same cmdlet parameter, the validate set is ignored and rule (6) applies to the remaining validate patterns.

O exemplo abaixo mostra como as funções são mescladas de acordo com essas regras:Below is an example of how roles are merged according to these rules:

# Role A Visible Cmdlets
$roleA = @{
    VisibleCmdlets = 'Get-Service',
                     @{ Name = 'Restart-Service'; Parameters = @{ Name = 'DisplayName'; ValidateSet = 'DNS Client' } }
}

# Role B Visible Cmdlets
$roleB = @{
    VisibleCmdlets = @{ Name = 'Get-Service'; Parameters = @{ Name = 'DisplayName'; ValidatePattern = 'DNS.*' } },
                     @{ Name = 'Restart-Service'; Parameters = @{ Name = 'DisplayName'; ValidateSet = 'DNS Server' } }
}

# Resulting permisisons for a user who belongs to both role A and B
# - The constraint in role B for the DisplayName parameter on Get-Service is ignored becuase of rule #4
# - The ValidateSets for Restart-Service are merged because both roles use ValidateSet on the same parameter per rule #5
$mergedAandB = @{
    VisibleCmdlets = 'Get-Service',
                     @{ Name = 'Restart-Service'; Parameters = @{ Name = 'DisplayName'; ValidateSet = 'DNS Client', 'DNS Server' } }
}

VisibleExternalCommands, VisibleAliases, VisibleProviders, ScriptsToProcessVisibleExternalCommands, VisibleAliases, VisibleProviders, ScriptsToProcess

Todos os outros campos no arquivo de capacidade de função são simplesmente adicionados a um conjunto cumulativo de comandos externos permitidos, aliases, provedores e scripts de inicialização.All other fields in the role capability file are simply added to a cumulative set of allowable external commands, aliases, providers, and startup scripts. Qualquer comando, alias, provedor ou script disponível em um capacidade de função estará disponível para o usuário JEA.Any command, alias, provider, or script available in one role capability will be available to the JEA user.

Verifique com cuidado se o conjunto combinado de provedores de um capacidade de função e funções/cmdlets/comandos de outro recurso de função não permitem aos usuários que estão se conectando o acesso involuntário aos recursos do sistema.Be careful to ensure that the combined set of providers from one role capability and cmdlets/functions/commands from another do not allow connecting users unintentional access to system resources. Por exemplo, se uma função permite o cmdlet Remove-Item e outra função permite o provedor FileSystem, haverá um risco de um usuário JEA excluir arquivos arbitrários no seu computador.For example, if one role allows the Remove-Item cmdlet and another allows the FileSystem provider, you are at risk of a JEA user deleting arbitrary files on your computer. Informações adicionais sobre como identificar as permissões efetivas dos usuários podem ser encontradas no tópico auditoria do JEA.Additional information about identifying users' effective permissions can be found in the auditing JEA topic.

Próximas etapasNext steps