Conceda FullTrust em assembly confiável chamado por assembly de confiança parcial

Question

imagine o seguinte ambiente:um XBAP aplicação sendo executada em modo de confiança parcial (comportamento padrão;exigir confiança total não é uma opção - mas antes que você pergunte, se for dada total confiança ao XBAP, tudo funciona conforme o esperado) faz referência a um assembly instalado localmente, localizado no GAC.Para conseguir isso, habilitamos o "AllowPartiallyTrustedCallers"opção à assembleia local, e também é concedida total confiança.(imagine que isso seja algum tipo de contrapartida de conectividade local)

(a propósito, estamos cientes dos aspectos de segurança do uso do atributo AllowPartiallyTrustedCallers, mas isso está fora do escopo desta postagem, mas não me importo)

Agora, mesmo que nossa assembleia local do GAC tenha confiança total (podemos verificar isso ligando para Assembly.GetExecutingAssembly().IsFullyTrusted a qualquer momento), ele falhará em qualquer demanda (implícita ou explícita), pois é chamado por um chamador parcialmente confiável (nosso XBAP). (corrija-me se eu estiver entendendo mal alguma coisa).Felizmente, podemos fazer declarações explícitas para obter permissões dentro de nosso assembly local do GAC, por exemplo:

new System.Security.Permissions.FileIOPermission(.....).Assert();

Com isso, poderíamos evitar um full stack walk nas demandas neste ponto e fazer qualquer acesso aos arquivos que quisermos.(novamente, por favor me corrija...)Na verdade, isso funciona perfeitamente! (nesse caso)

O problema é que simplesmente não fazemos nenhum IO de arquivo; na verdade, estamos chamando bibliotecas externas que deveria ser capaz de fazer o que quiserem (e eles podem fazer muitas coisas, acessando o registro, fazendo solicitações de serviços da web, escrevendo arquivos, chamando código não gerenciado - não sabemos detalhes, mas podemos confiar neles) e impedir que a pilha de demanda chegue ao nosso chamador parcialmente confiável.Deveríamos ser capazes de conseguir isso, já que tudo é feito a partir de nosso assembly GAC confiável e instalado localmente.(novamente, não se preocupe com os aspectos de segurança aqui, apenas presuma que podemos confiar no cliente)

Abordagem para resolver isso:

• O que pensamos primeiro foi afirmar um conjunto de permissões (PermissionSet) para quase qualquer permissão antes de trabalhar com a biblioteca externa.Isso quase funciona, mas parece que em algum momento ainda ocorre uma exceção de segurança - seja porque a biblioteca externa pode iniciar mais threads que falham por algum motivo, ou porque está acessando o assembly de entrada - na verdade, não sabemos.

• Em segundo lugar, tentamos o seguinte atributo

[System.Security.Permissions.PermissionSet(
  System.Security.Permissions.SecurityAction.Assert, Name = "FullTrust")]

também não funcionou.

• Terceiro, pensamos em abrir um novo AppDomain, tornando o GAC totalmente confiável montando o ponto de entrada do AppDomains e executando qualquer coisa dentro deste appdomain - qualquer caminhada na pilha nunca mais poderia alcançar o chamador parcialmente confiável - em nossa teoria).Infelizmente não conseguimos isso...Ou o AppDomain recém-criado falha ainda mais nas demandas, mesmo se configurado para ser executado em zonas de segurança "MyComputer" Evidence ou SecurityPermission irrestrita.Não consigo conceder explicitamente confiança total a todo o AppDomain.

• Quarto, usando caspol não é uma opção.(devido a motivos de implantação)

Agora, como deve ser muita informação, espero que você entenda o que queremos arquivar.

Para ir direto ao ponto: Como um assembly totalmente confiável pode afirmar uma confiança total nos assemblies que ele chama, interrompendo todas as caminhadas na pilha para alcançar o chamador parcialmente confiável?

Muito obrigado antecipadamente

Answer 1

Olhando a documentação da Microsoft em relação à permissão Chamadores Parcialmente Confiáveis ​​para Assemblies de Confiança Total Não acredito que isso seja possível.

Você continua enfatizando que precisamos evitar as preocupações de segurança, mas, na realidade, o que você está tentando fazer com sua solução é ignorar essencialmente todas as partes do sistema de segurança de acesso ao código no .NET Framework, e serei duro pressionados a acreditar que conseguirão encontrar uma solução viável.

Além disso, não consigo imaginar que esse processo seja algo que realmente precise ser feito dessa forma.

Você não poderia descarregar esse processamento do chamador parcialmente confiável para então passar as comunicações para algo executado localmente e já confiável?