Compartilhar via

Problemas de segurança no reflexão Emit

  • Artigo

The .NET Framework fornece três maneiras de emitir Microsoft intermediate linguagem (MSIL), cada um com seus próprios problemas de segurança:

  • Assemblies dinâmicos

  • Hospedado anonimamente métodos dinâmicos

  • Métodos dinâmicos associados com assemblies existentes

Independentemente da maneira como você gera código dinâmico, executar o código gerado requer todas as permissões necessários para os tipos e métodos que usa o código gerado.

Observação:

As permissões que são necessário para refletir nos códigos e emitindo código foram alterados com êxito versões dos .NET Framework.See Informações de versão, neste tópico.

Assemblies dinâmicos

Assemblies dinâmicos são criados usando sobrecargas do AppDomain.DefineDynamicAssembly método. As permissões necessárias dependem a sobrecarga é usada.Sobrecarrega a fonte evidência, por exemplo, exigir SecurityPermission com o SecurityPermissionFlag.ControlEvidence sinalizar. Algumas sobrecargas não requerem permissões de nenhuma e podem ser chamadas do código tem somente permissões de Internet.

Código em um assembly dinâmico pode acesso visíveis tipos e membros em outros módulos (assemblies).

Observação:

Assemblies dinâmicos não usam o ReflectionPermissionFlag.MemberAccess e ReflectionPermissionFlag.RestrictedMemberAccess sinalizadores que permitem que os métodos dinâmicos acessar confidenciais tipos e membros.

Gerando código com símbolos de depurar requer ReflectionPermission com o ReflectionPermissionFlag.ReflectionEmit sinalizar.

Transitórios assemblies dinâmicos são criados na memória e nunca salvos em disco, para que eles exigem permissões de acesso nenhum arquivo.Salvar um assembly dinâmico para disco requer FileIOPermission com os sinalizadores adequados.

Gerando assemblies dinâmicos a partir do código parcialmente confiável

Considere as condições em que um assembly com permissões de Internet pode gerar um assembly dinâmico transitório e executar seu código:

  • O assembly dinâmico usa apenas tipos públicos e membros de outros módulos (assemblies).

  • As permissões exigidas por esses tipos e membros são incluídas no conjunto de concessão do assembly parcialmente confiável.

  • The DefineDynamicAssembly sobrecarga de método é usada para criar o assembly dinâmico requer sem permissões de acesso especiais (ou seja, nenhuma evidência for fornecida e assim por diante).

  • O assembly não é salva em disco.

  • Depurar símbolos não são gerados.(Internet e LocalIntranet conjuntos de permissão não incluem o ReflectionPermissionFlag.ReflectionEmit sinalizar).

Estabelecer permissões para conjuntos dinâmicos

Na lista a seguir, "emissor" é o assembly que gera o conjunto dinâmico.

  • Um emissor que tenha SecurityPermission com o SecurityPermissionFlag.ControlEvidence sinalizar pode fornecer evidência para o código gerado. Esta evidência é mapeada por meio de diretiva para determinar as permissões concedidas.

  • Um emissor pode fornecer provas nula, caso o assembly obtém o conjunto de permissões de que o emissor.Isso assegura que o código gerado não tem mais permissões que seu emissor.

  • Se você fornecer conjuntos de permissões com SecurityAction.RequestMinimum, SecurityAction.RequestOptional, ou SecurityAction.RequestRefuse, os conjuntos de permissão não obter usados até que o assembly tenha sido salvo em disco e carregado a partir do disco.

  • Depois que um assembly dinâmico for salvo em disco, o assembly é tratado como qualquer assembly carregado a partir do disco.

  • Código gerado pelo emitters semiconfiável sempre é verificado.Especificamente, o tempo de execução sempre verifica o código que não tenha SecurityPermission com o SecurityPermissionFlag.SkipVerification sinalizar. Emitters totalmente confiável podem ignorar a verificação ou exigir o código gerado seja verificado.

Hosted anonimamente métodos dinâmicos

Anonimamente hospedados métodos dinâmicos são criados usando os dois DynamicMethod construtores não especificam um tipo associado ou módulo, DynamicMethod(String, Type, array<Type[]) e DynamicMethod(String, Type, array<Type[], Boolean). Esses construtores coloque métodos dinâmicos em um assembly fornecido pelo sistema, totalmente confiável, segurança transparente.Sem permissões são necessárias para usar esses construtores ou emita código para os métodos dinâmicos.

Em vez disso, quando um método dinâmico anonimamente hospedado é criado, o telefonar pilha é capturada.Quando o método é construído, demandas de segurança são feitas em relação a capturados telefonar pilha.

Observação:

Conceitualmente, por solicitação s são feitas durante a o construção do método.Ou seja, demandas pode ser feitas Como cada MSIL instrução é emitida.Na implementação corrente , todos os as demandas são feitas Quando o DynamicMethod.CreateDelegate método é chamado ou quando o compilador just-in-time (JIT) é chamado, se o método for chamado sem chamada CreateDelegate.

Métodos dinâmicos anonimamente hospedados poderá ignorar verificações de visibilidade JIT, sujeito a seguinte restrição: A confidenciais tipos e membros acessados por um método dinâmico anonimamente hospedado devem estar em módulos (assemblies) cuja concessão define são igual a ou subconjuntos de conjunto de emitindo a concessão telefonar pilha.Essa capacidade restrita para pular verificações de visibilidade JIT requer ReflectionPermission com o ReflectionPermissionFlag.RestrictedMemberAccess sinalizar.

  • Se seu método usa apenas tipos públicos e os membros, não há permissões são necessárias durante a construção.

  • Se você especificar que o JIT visibilidade verificações deve ser ignorado, a solicitação é feita quando o método é construído inclui ReflectionPermission com o ReflectionPermissionFlag.RestrictedMemberAccess sinalizar e o concessão de conjunto de módulos (assembly) que contém o membro confidenciais que está sendo acessado.

Porque a concessão definido de membro confidenciais é levado em consideração, código parcialmente confiável tenha sido concedida ReflectionPermissionFlag.RestrictedMemberAccess não é possível elevar seus privilégios, executando membros confidenciais de assemblies confiáveis.

sistema autônomo em qualquer Outros código emitido, executar o método dinâmico requer sistema autônomo permissões são exigidas pelos métodos que usa o método dinâmico.

Para mais informações, consulte a classe DynamicMethod.

Gerando anônimo Hosted métodos dinâmicos de códigos parcialmente confiável

Considere as condições em que um assembly com permissões de Internet pode gerar um método dinâmico anonimamente hospedado e executá-lo:

  • O método dinâmico usa apenas tipos públicos e membros.Se seu conjunto de concessão inclui ReflectionPermissionFlag.RestrictedMemberAccess, ele pode usar confidenciais tipos e membros de qualquer assembly cuja concessão definido é igual a ou um subconjunto do conjunto de concessão do assembly emissão.

  • As permissões que são necessários para todos os tipos e membros usados pelo método dinâmico são incluídas no conjunto de concessão do assembly parcialmente confiável.

Observação:

Métodos dinâmicos não dão suporte a símbolos de depurar.

Métodos dinâmicos associados com conjuntos existentes

Para associar um método dinâmico a um tipo ou módulo em um assembly existente, use qualquer um do DynamicMethod construtores que especifique o tipo associado ou módulo. As permissões necessárias para chamar esses construtores variam, como associar um método dinâmico de um tipo existente ou módulo concede o acesso do método dinâmico aos confidenciais tipos e membros:

  • Um método dinâmico que está associado um tipo tem acesso a todos os membros desse tipo, até mesmo os membros privados, e para todos os tipos internos e membros no conjunto de módulos (assembly) que contém o tipo associado.

  • Um método dinâmico que está associado um módulo tem acesso a todos os internal (tipos e membrosFriend no Visual Basic assembly nos metadados de tempo de execução linguagem comum) no módulo.

Além disso, você pode usar um construtor que especifica verifica a capacidade de ignorar a visibilidade do compilador JIT.Isso permite seu acesso método dinâmico à todos os tipos e membros em todos os assemblies, independentemente do nível de acesso.

As permissões exigidas pelo construtor dependem quanto acesso decidir dar seu método dinâmico:

Embora os itens desta lista são descritos em termos de conjunto de concessão de módulos (assembly) emissão, lembre-se de que as demandas são feitas em relação a pilha de chamadas completa, incluindo limites de domínio do aplicativo.

Para mais informações, consulte a classe DynamicMethod.

Gerando métodos dinâmicos a partir do código parcialmente confiável

Observação:

A maneira recomendada para gerar métodos dinâmicos a partir de código parcialmente confiável é usar hospedado anonimamente métodos dinâmicos.

Considere as condições em que um assembly com permissões de Internet pode gerar um método dinâmico e executá-lo:

  • Talvez seja associado ao módulo ou tipo ele emite o método dinâmico ou seu conjunto de concessão inclui ReflectionPermissionFlag.RestrictedMemberAccess e está associado a um módulo em um assembly cuja concessão conjunto é igual a ou um subconjunto do conjunto concessão do assembly emissão.

  • O método dinâmico usa apenas tipos públicos e membros.Se seu conjunto de concessão inclui ReflectionPermissionFlag.RestrictedMemberAccess e está associado a um módulo em um assembly cuja concessão conjunto é igual a ou um subconjunto do conjunto de concessão do assembly emissão, ele pode usar tipos e membros marcados internal (Friend no Visual Basic assembly em Common Language tempo de execução metadados) no módulo associado.

  • As permissões exigidas por todos os tipos e membros usados pelo método dinâmico são incluídos no conjunto de concessão do assembly parcialmente confiável.

  • O método dinâmico não ignorar verificações de visibilidade JIT.

Observação:

Métodos dinâmicos não dão suporte a símbolos de depurar.

Informações sobre versão

Iniciando com o .NET Framework versão 2.0 Service Pack 1, ReflectionPermission com o ReflectionPermissionFlag.ReflectionEmit sinalizar não é necessário quando emitindo métodos dinâmicos e assemblies dinâmicos. Este sinalizar é necessário em todas as versões anteriores do .NET Framework.

Observação:

ReflectionPermission com o ReflectionPermissionFlag.ReflectionEmit sinalizar é incluído por padrão na FullTrust e LocalIntranet conjuntos de permissões nomeadas, mas não o Internet conjunto de permissões. Portanto, em versões anteriores do .NET Framework, uma biblioteca pode ser usada com as permissões de Internet somente se ele executa um Assert para ReflectionEmit. Essas bibliotecas exigem revisão de segurança cuidadosa porque erros de código podem resultar em falhas de segurança.The .NET Framework 2,0 SP1 permite que o código ser emitido em cenários de confiança parcial sem emitir as demandas de segurança, como geração de código não é inerentemente uma operação privilegiada. Ou seja, o código gerado tem não mais permissões que o assembly que ela emite.Isso permite que bibliotecas que emitem código seja segurança transparente e remove a necessidade de declarar ReflectionEmit, que simplifica a tarefa de escrever uma biblioteca de segura.

Além disso, a .NET Framework 2,0 SP1 apresenta o ReflectionPermissionFlag.RestrictedMemberAccess sinalizar para acessar confidenciais tipos e membros de métodos dinâmicos parcialmente confiável. Versões anteriores do .NET Framework exigir o ReflectionPermissionFlag.MemberAccess sinalizar para métodos dinâmicos que acessam confidenciais tipos e membros; esta é uma permissão que nunca deve ser concedida ao código parcialmente confiável.

Finalmente, a .NET Framework 2,0 SP1 apresenta métodos anonimamente hospedados.

Para usar esses recursos, seu aplicativo deve visar o .NET Framework versão 3.5. Para obter mais informações, consulte Arquitetura do .NET Framework 3.5.

Obtendo informações sobre tipos e membros

Iniciando com o .NET Framework 2,0, não há permissões são necessárias para obter informações sobre tipos confidenciais e membros. Reflexão é usada para obter as informações necessárias para emitir métodos dinâmicos.Por exemplo, MethodInfo os objetos são usados para emitir chamadas de método. Versões anteriores do .NET Framework exigir ReflectionPermission com o ReflectionPermissionFlag.TypeInformation sinalizar. Para obter mais informações, consulte Considerações de segurança para reflexão.

Consulte também

Conceitos

Considerações de segurança para reflexão

Outros recursos

Emitindo Métodos Dinâmicos e Assemblies