Criando um cache de token local usando o Framework de Genebra

StackOverflow https://stackoverflow.com/questions/400246

Pergunta

não vi muitas questões relacionadas Genebra ainda, eu colocaram esta questão no Genebra Fórum bem ...

Eu estou trabalhando em um cenário onde temos um aplicativo de formulários de vitória com uma ampla installbase, que estará emitindo chamadas freqüentes para vários serviços hospedados por nós centralmente em toda a sua operação.

Os serviços estão todos usando o Quadro de Genebra e todos os clientes são esperados para chamar nossos STS primeiro a ser emitidas com um token para permitir o acesso aos serviços.

Fora da caixa, usando o ws2007FederationHttpBinding, o aplicativo pode ser configurado para recuperar um token do STS antes de cada chamada de serviço, mas, obviamente, esta não é a forma mais eficiente como nós estamos quase duplicar o esforço de chamar os serviços .

Como alternativa, eu ter implementado o código necessário para recuperar o token "manualmente" a partir da aplicação e, em seguida, passar o pré-recuperado de token ao chamar operações nos serviços (com base na amostra WSTrustClient e Ajuda na forum) mesmo; que funciona bem e assim nós temos uma solução, mas eu believeit não é muito elegante, uma vez que exige a construção do canal WCF em código, afastando-se a configuração WCF maravilhoso.

Eu prefiro muito mais a abordagem ws2007FederationHttpBinding onde pelo cliente simplesmente chama o serviço como qualquer outro serviço WCF, sem saber nada sobre Genebra, e as ligações cuida da troca simbólica.

alguém Então (Jon Simpson) me deu [o que eu penso é] uma grande idéia - adicionar um serviço, hospedado no próprio aplicativo para armazenar em cache os tokens recuperados localmente. O serviço cache local iria implementar o mesmo contrato como o STS; quando receber um pedido que iria verificar para ver se existe um símbolo cahced, e se isso iria devolvê-lo, caso contrário ele iria chamar os STS 'reais', retrive um novo token, cache de-lo e devolvê-lo. O aplicativo cliente pode então ainda usar ws2007FederationHttpBinding, mas em vez de ter o STS como o emissor teria o cache local;

Desta forma, eu acho que nós podemos alcançar o melhor dos dois mundos - o cache de tokens sem o código personalizado serviço de sepcific; nosso cache deve ser capaz de lidar com fichas para todas as RPs.

Eu criei um protótipo muito simples para ver se ele funciona, e - um pouco não é surpreendente, infelizmente - Estou um pouco preso -

Meu serviço local (atualmente um console app) recebe o pedido, e - pela primeira vez ao redor - chama os STS para recuperar o token, armazena em cache-lo e com sucesso retorna para o cliente, que, posteriormente, usa-o para chamar a RP. tudo funciona bem.

segunda vez, no entanto, meus locais tentativas de serviços cahce usar o mesmo token novamente, mas o lado do cliente falhar com um MessageSecurityException -

"processador de Segurança foi incapaz de encontrar um cabeçalho de segurança na mensagem. Isso pode ser porque a mensagem é uma falha não segura ou porque há uma incompatibilidade de ligação entre as partes que se comunicam. Isso pode ocorrer se o serviço está configurado para a segurança e o cliente não estiver usando segurança. "

Há algo impedindo que o mesmo motivo para ser usado mais de uma vez? Eu duvido, porque quando eu reutilizado o token de acordo com a amostra WSTrustClient funcionou bem; o que estou perdendo? é a minha ideia possível? uma boa?

Aqui está o (muito básico, nesta fase) principais bits de código do cache local - 

    static LocalTokenCache.STS.Trust13IssueResponse  cachedResponse = null; 
    public LocalTokenCache.STS.Trust13IssueResponse Trust13Issue(LocalTokenCache.STS.Trust13IssueRequest request) 
    { 
        if (TokenCache.cachedResponse == null) 
        { 
            Console.WriteLine("cached token not found, calling STS"); 
            //create proxy for real STS 
            STS.WSTrust13SyncClient sts = new LocalTokenCache.STS.WSTrust13SyncClient(); 
            //set credentials for sts 
            sts.ClientCredentials.UserName.UserName = "Yossi"; 
            sts.ClientCredentials.UserName.Password = "p@ssw0rd"; 
            //call issue on real sts 
            STS.RequestSecurityTokenResponseCollectionType stsResponse = sts.Trust13Issue(request.RequestSecurityToken); 
            //create result object - this is a container type for the response returned and is what we need to return; 
            TokenCache.cachedResponse = new LocalTokenCache.STS.Trust13IssueResponse(); 
            //assign sts response to return value... 
            TokenCache.cachedResponse.RequestSecurityTokenResponseCollection = stsResponse; 
        } 
        else 
        { 
        } 
        //...and reutn 
        return TokenCache.cachedResponse;
Foi útil?

Solução

Isto é quase embaraçoso, mas graças a Dominick Baier no fórum eu não realizo agora que eu perdi um enorme ponto (eu sabia que não fazia sentido honestamente :-)!) -

Um token fica recuperada uma vez por proxy de serviço, assumindo que não tinha expirado, e assim tudo o que eu precisava fazer é reutilizar o mesmo proxy, o que eu planejava fazer de qualquer maneira, mas, sim, estupidamente, não no meu protótipo.

Além disso - eu encontrei uma amostra muito interessante sobre as amostras MSDN WCF - Durable Emitido Provedor de token, que, se eu entendi corretamente, usa um comportamento endpoint personalizada no lado do cliente para implementar o cache de token, que é muito elegante.

Eu ainda vai olhar para esta abordagem como temos vários serviços e para que pudéssemos alcançar ainda mais a eficiência, re-utilizando a mesma forma entre seus procuradores.

Assim - duas soluções, praticamente infornt dos meus olhos; espero que a minha estupidez ajuda alguém, em algum momento!

Outras dicas

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top