Problemas de segurança em reflexão emitir
O .NET Framework fornece três maneiras de emitir Microsoft intermediário language (MSIL), cada um com seus próprios problemas de segurança:
Assemblies dinâmicos
Anonimamente hospedado métodos dinâmicos
Métodos dinâmicos associados aos conjuntos existentes
Independentemente da forma de que gerar o código dinâmico, a execução do código gerado requer todas as permissões que são necessários para os tipos e métodos que usa o código gerado.
Observação
As permissões que são necessárias para refletindo no código e emitindo um código foram alteradas com êxito de versões da .NET Framework.Consulte Informações sobre a versão, posteriormente neste tópico.
Assemblies dinâmicos
Assemblies dinâmicos são criados usando as sobrecargas da AppDomain.DefineDynamicAssembly método. A maioria das sobrecargas desse método são preteridas na .NET Framework versão 4, por causa da eliminação da diretiva de segurança da máquina. (See Alterações de segurança na.NET Framework 4.) Sobrecargas de restantes podem ser executadas por qualquer código, independentemente do nível de confiança. Essas sobrecargas dividem-se em dois grupos: aqueles que especificar uma lista de atributos a serem aplicados ao assembly dinâmico quando ele é criado e os que não. Se você não especificar o modelo Transparência do assembly, aplicando o SecurityRulesAttribute atributo quando criá-la, o modelo Transparência é herdado do assembly de emissão.
Observação
Atributos que se aplicam ao assembly dinâmico depois de criado, usando o SetCustomAttribute método, não terão efeito até que o assembly foi salvo no disco e carregado na memória novamente.
O código em um assembly dinâmico pode acessar visíveis tipos e membros em outros 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 tipos confidenciais e membros.
Transitórios assemblies dinâmicos são criados na memória e nunca são salvos em disco, para que eles exigem nenhuma permissão de acesso do arquivo. Salvando um assembly dinâmico disco requer FileIOPermission com sinalizadores apropriados.
Gerando Assemblies dinâmicos a partir do código parcialmente confiável
Considere as condições de 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 assemblies.
As permissões exigidas por esses tipos e membros são incluídas no conjunto de concessão do assembly parcialmente confiável.
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 permissões necessárias.)
Anonimamente hospedado métodos dinâmicos
Hospedado anonimamente métodos dinâmicos são criados usando os dois DynamicMethod construtores que não especificam um tipo associado ou módulo, DynamicMethod(String, Type, Type[]) e DynamicMethod(String, Type, Type[], Boolean). Esses construtores coloque os métodos dinâmicos em um assembly fornecido pelo sistema, totalmente confiável, transparente para a segurança. Não são necessárias permissões 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, a pilha de chamadas é capturada. Quando o método é construído, as exigências de segurança são feitas em relação a pilha de chamadas capturados.
Observação
Conceitualmente, demandas são feitas durante a construção do método.Ou seja, demandas podem ser feitas como cada instrução MSIL é emitida.Na implementação atual, todas as demandas são feitas quando o DynamicMethod.CreateDelegate método é chamado ou quando compilador just-in-time (JIT) é chamado, se o método for chamado sem chamada CreateDelegate.
Se o domínio de aplicativo permite que ele, anonimamente hospedados métodos dinâmicos podem ignorar as verificações de visibilidade JIT, sujeito a seguinte restrição: Os tipos de confidenciais e acessados por um método dinâmico anonimamente hospedado de membros devem ser em assemblies cuja concessão conjuntos são iguais a ou subconjuntos de conjunto de concessão da pilha de chamadas de emissão. Essa possibilidade restrita para ignorar a visibilidade JIT verifica estará habilitado se o domínio do aplicativo concede ReflectionPermission com o ReflectionPermissionFlag.RestrictedMemberAccess sinalizador.
Se seu método usa apenas tipos públicos e membros, não há permissões são necessárias durante a construção.
Se você especificar que a visibilidade JIT verificações deve ser ignorado, a demanda que é feita quando o método é construído inclui ReflectionPermission com o ReflectionPermissionFlag.RestrictedMemberAccess sinalizador e o conjunto de concessão do assembly que contém o membro confidenciais que está sendo acessado.
Porque o conjunto de concessão do membro confidenciais sejam levado em consideração, código parcialmente confiável que recebeu ReflectionPermissionFlag.RestrictedMemberAccess não pode elevar seus privilégios, executando membros confidenciais dos assemblies confiáveis.
Como com qualquer outro código emitido, a execução do método dinâmico requer quaisquer permissões que são exigidas pelos métodos que usa o método dinâmico.
O assembly de sistema que hospeda os métodos dinâmicos anonimamente hospedado usa a modelo de transparência deSecurityRuleSet.Level1 , que é o modelo de transparência foi usado na.NET Framework antes de .NET Framework 4.
Para mais informações, consulte a classe DynamicMethod.
Gerando anonimamente hospedado métodos dinâmicos a partir do código parcialmente confiável
Considere as condições de 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 o 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 de emissão.
As permissões exigidas por todos os tipos e membros usados pelo método dinâmico estão incluídas no conjunto de concessão do assembly parcialmente confiável.
Observação
Métodos dinâmicos não oferecem suporte a símbolos de depuração.
Métodos dinâmicos associados aos conjuntos existentes
Para associar um método dinâmico com um tipo ou o módulo em um assembly existente, use qualquer um do DynamicMethod construtores que especificam o tipo associado ou módulo. As permissões que são necessárias para chamar esses construtores variam, como associar um método dinâmico de um tipo existente ou módulo fornece o acesso de método dinâmico para membros e tipos confidenciais:
Um método dinâmico que está associado um tipo tem acesso a todos os membros desse tipo, até mesmo membros de particulares, e todos os tipos internos e membros no assembly que contém o tipo de associado.
Um método dinâmico que está associado um módulo tem acesso a todos os internal tipos e membros (Friend em Visual Basic, assembly nos metadados de tempo de execução de linguagem comum) no módulo.
Além disso, você pode usar um construtor que especifica a capacidade de ignorar a visibilidade verifica do compilador JIT. Isso proporciona o acesso do método dinâmico para 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:
Se seu método usa tipos e membros públicos somente e associá-lo com seu próprio tipo ou seu próprio módulo, não há permissões são necessárias.
Se você especificar que as verificações de visibilidade do JIT devem ser ignoradas, o construtor demandas ReflectionPermission com o ReflectionPermissionFlag.MemberAccess sinalizador.
Se você associar o método dinâmico com outro tipo, até mesmo outro tipo de seu próprio assembly, o construtor demandas ReflectionPermission com o ReflectionPermissionFlag.MemberAccess sinalizador e SecurityPermission com o SecurityPermissionFlag.ControlEvidence sinalizador.
Se você associar um método dinâmico com um tipo ou o módulo em outro assembly, o construtor exige duas coisas: ReflectionPermissioncom o ReflectionPermissionFlag.RestrictedMemberAccess conjunto de sinalizador e a concessão do assembly que contém o outro módulo. Ou seja, a sua pilha de chamadas deve incluir todas as permissões no conjunto de concessão do módulo de destino, além de ReflectionPermissionFlag.RestrictedMemberAccess.
Observação
Para compatibilidade com versões anteriores, se a demanda para o destino de conceder o conjunto mais ReflectionPermissionFlag.RestrictedMemberAccess falhar, as demandas no construtor SecurityPermission com o SecurityPermissionFlag.ControlEvidence sinalizador.
Embora os itens nesta lista são descritos em termos de conjunto de concessão do assembly de emissão, lembre-se de que as demandas são feitas em relação a pilha de chamada completo, incluindo os 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 o métodos dinâmicos do código parcialmente confiável é usar anonimamente hospedado métodos dinâmicos.
Considere as condições de um assembly com permissões de Internet pode gerar um método dinâmico e executá-lo:
O método dinâmico está associado com o módulo ou um tipo que emite a ele 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 de concessão do assembly de emissão.
O método dinâmico usa apenas tipos públicos e membros. Se o 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 de emissão, ele pode usar tipos e membros marcados como internal (Friend em Visual Basic, assembly nos metadados de tempo de execução de linguagem comum) no módulo associado.
Permissões exigidas por todos os tipos e membros usados pelo método dinâmico estão incluídos no conjunto de concessão do assembly parcialmente confiável.
O método dinâmico não ignora as verificações de visibilidade JIT.
Observação
Métodos dinâmicos não oferecem suporte a símbolos de depuração.
Informações sobre versão
Começando com o .NET Framework 4, a diretiva de segurança de toda a máquina é eliminada e transparência da segurança se torna o mecanismo de imposição de padrão. Consulte Alterações de segurança na.NET Framework 4.
Começando com o .NET Framework versão 2.0 Service Pack 1, ReflectionPermission com o ReflectionPermissionFlag.ReflectionEmit sinalizador é não mais necessário ao emitir assemblies dinâmicos e métodos dinâmicos. Esse sinalizador é necessária em todas as versões anteriores do .NET Framework.
Observação
ReflectionPermissioncom o ReflectionPermissionFlag.ReflectionEmit sinalizador é incluído por padrão na FullTrust e LocalIntranet conjuntos de permissões nomeadas, mas não o Internet conjunto de permissão.Portanto, em versões anteriores da .NET Framework, uma biblioteca pode ser usada com permissões de Internet somente se ele executa uma Assert para ReflectionEmit.Essas bibliotecas exigem análise cuidadosa de segurança porque os erros de codificação pode resultar em falhas de segurança.O .NET Framework 2.0 SP1 permite que o código a ser emitido em cenários de confiança parcial, sem emitir nenhum demandas de segurança, pois a geração de código é não inerentemente um privilegiado operação.Ou seja, o código gerado tem não mais permissões do assembly que emite a ele.Isso permite que as bibliotecas que emitem o código para ser transparente de segurança e elimina a necessidade de declarar ReflectionEmit, que simplifica a tarefa de escrever uma biblioteca de seguro.
Além disso, o .NET Framework 2.0 SP1 apresenta o ReflectionPermissionFlag.RestrictedMemberAccess o sinalizador de acesso confidenciais tipos e membros de métodos dinâmicos parcialmente confiável. Versões anteriores da .NET Framework exigem o ReflectionPermissionFlag.MemberAccess Sinalizador para métodos dinâmicos que acessem confidenciais tipos e membros; Esta é uma permissão que nunca deve ser concedida ao código parcialmente confiável.
Finalmente, o .NET Framework 2.0 SP1 apresenta métodos anonimamente hospedado.
Obtendo informações sobre tipos e membros
Começando com o .NET Framework 2.0, não há permissões são necessárias para obter informações sobre os tipos de confidenciais e membros. Reflexão é usada para obter as informações necessárias para emitir métodos dinâmicos. Por exemplo, MethodInfo objetos são usados para emitir chamadas de método. Versões anteriores da .NET Framework exigem ReflectionPermission com o ReflectionPermissionFlag.TypeInformation sinalizador. 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