Configurando Tokens de Segurança de Gerador Utilizando a API WSS

É possível proteger as mensagens SOAP, sem usar os conjuntos de política, utilizando as Web Services Security APIs. Para configurar o token no lado do gerador, utilize as WSS APIs (Web Services Security APIs). Os tokens de segurança do gerador são partes do pacote da interface com.ibm.websphere.wssecurity.wssapi.token.

Antes de Iniciar

A estrutura de token que pode ser conectado no WebSphere Application Server foi reprojetada, de forma que a mesma estrutura da API WSS possa ser reutilizada. A mesma implementação da criação e da validação do token de segurança pode ser utilizada para o tempo de execução do Web Services Security e para o código de aplicativo WSS API. A estrutura reprojetada também simplifica o modelo de programação SPI e facilitará a inclusão de tipos de token de segurança.

É possível utilizar a WSS API ou é possível configurar os tokens, utilizando o console administrativo. Para configurar os tokens, é necessário concluir as seguintes tarefas de token:

  • Configurar os tokens do gerador.
  • Configurar os tokens do consumidor.

Sobre Esta Tarefa

O JAAS CallbackHandler e o JAAS LoginModule são responsáveis por criar o token de segurança no lado do gerador.

No lado do gerador, o token é criado utilizando o JAAS LoginModule e utilizando o JAAS CallbackHandler para transmitir os dados de autenticação. Depois, o JAAS LoginModule cria o objeto securityToken, como o UsernameToken, e o passa para o tempo de execução da Segurança de Serviços da Web.

No lado do consumidor, o formato XML é transmitido ao JAAS LoginModule para validação ou autenticação. Depois, o JAAS CallbackHandler é usado para passar dados de autenticação do tempo de execução da Segurança de Serviços da Web para o LoginModule. Após a autenticação do token e da criação de um objeto de token de segurança, o token é passado para o tempo de execução da Segurança de Serviços da Web.

Ao utilizar a WSS API para criação de token do gerador, ocorrem determinados comportamentos padrão. A maneira mais simples de utilizar a WSS API é utilizar o comportamento padrão (consulte o código de exemplo). A WSS API fornece valores padrão para o tipo de token, o valor do token e o nome de confirmação JAAS. Os comportamentos de token padrão incluem:

Tabela 1. Decisões e Comportamentos Padrão de Tokens. Várias características de token são configuradas por padrão.
Decisões de Token do Gerador Comportamento Padrão
Qual tipo de token utilizar

Especifica o tipo de token a ser utilizado para integridade da mensagem, sigilo da mensagem ou autenticidade da mensagem.

O WebSphere Application Server fornece os seguintes tipos de token de gerador pré-configurados para integridade da mensagem e sigilo da mensagem:
  • Token de chave derivado
  • Tokens X509
Também é possível criar tipos de token customizados, conforme necessário.

O WebSphere Application Server também fornece os seguintes tipos de token de gerador pré-configurados para a autenticidade da mensagem:

  • Token de Nome de Usuário
  • Tokens LTPA
  • Tokens X509

Também é possível criar tipos de token customizados, conforme necessário.

Qual nome de configuração de login JAAS especificar

O nome de configuração de login JAAS especifica qual nome de configuração de login JAAS utilizar.

Qual tipo de configuração utilizar O módulo de login JAAS especifica o tipo de configuração. Apenas os tipos de configuração do gerador pré-configurado podem ser utilizados para os tipos de token do gerador.

A classe SecurityToken (com.ibm.websphere.wssecurity.wssapi.token.SecurityToken) é a classe de token genérica e representa o token de segurança que possui métodos para obter a identidade, o formato XML e as chaves criptográficas. Utilizando a classe SecurityToken, é possível aplicar a assinatura e a criptografia para a mensagem SOAP. No entanto, para aplicar ambos, é necessário ter dois objetos SecurityToken, um para assinatura e um para criptografia, respectivamente.

Os seguintes tipos de tokens são subclasses da classe do token de segurança genérico:

Tabela 2. As subclasses do SecurityToken. Utilize as subclasses para representar o token de segurança.
Tipo de Token Nome de configuração de login JAAS
Token de Nome de Usuário system.wss.generate.unt
Token de Contexto de Segurança system.wss.generate.sct
Token de chave derivado system.wss.generate.dkt

Os seguintes tipos de tokens são subclasses da classe do token de segurança binário:

Tabela 3. Subclasses do BinarySecurityToken. Utilize as subclasses para representar o token de segurança binário.
Tipo de Token Nome de configuração de login JAAS
Token LTPA system.wss.generate.ltpa
Token de Propagação LTPA system.wss.generate.ltpaProp
Token X.509 system.wss.generate.x509
Token do Caminho X.509 PKI system.wss.generate.pkiPath
Token X.509 PKCS7 system.wss.generate.pkcs7
Nota:
  • Para cada nome de configuração do gerador do token de login JAAS, existe um respectivo nome de configuração do consumidor de token. Por exemplo, para o token de Nome do Usuário, o respectivo nome de configuração do consumidor de token é system.wss.consume.unt.
  • Os tokens de propagação LTPA e LTPA estão disponíveis apenas para um solicitante que estiver sendo executado como um cliente baseado em servidor. O LTPA e os tokens de propagação LTPA não são suportados para o aplicativo cliente Java™ SE 6 ou Java EE.

Procedimento

  1. Para configurar o pacote securityToken, com.ibm.websphere.wssecurity.wssapi.token, primeiro assegure-se de que o servidor de aplicativos esteja instalado.
  2. Utilize o processo do gerador do token Web Services Security para configurar os tokens. Para cada tipo de token, o processo é semelhante ao seguinte processo que demonstra o processo do gerador de token UsernameToken:
    1. Use WSSFactory.getInstance() para obter a instância de implementação da API WSS.
    2. Crie a instância WSSGenerationContext a partir da instância WSSFactory.
    3. Crie um CallbackHandler do JAAS. Os dados de autenticação, como o nome do usuário e a senha são especificados como parte do CallbackHandler. Por exemplo, o seguinte código especifica Chris como o nome de usuário e sirhC como a senha: UNTGenerationCallbackHandler("Chris", "sirhC");
    4. Chame quaisquer parâmetros CallbackHandler do JAAS e revise as informações de classe do token para quais parâmetros são necessários ou opcionais. Por exemplo, para UsernameToken, os seguintes parâmetros também podem ser configurados:
      Nonce
      Indica se um nonce é incluído no token de nome do usuário para o gerador de token. Nonce é um número criptográfico exclusivo incorporado em uma mensagem para ajudar a interromper repetidos ataques não autorizados de tokens do nome do usuário. O valor de nonce é válido apenas quando o tipo de token gerado for um UsernameToken e apenas quando se aplicar à ligação do gerador de pedido.
      Registro de Data e Hora Criado
      Indica se é necessário inserir um registro de data e hora no UsernameToken. O valor de registro de data e hora é válido apenas quando o tipo de token gerado for um UsernameToken e apenas quando se aplicar à ligação do gerador de pedido.
    5. Crie o SecurityToken a partir de WSSFactory.

      Por padrão, a API UsernameToken especifica o ValueType como: "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#UsernameToken"

      Por padrão, a API UsernameToken fornece o QName desta classe e especifica NamespaceURI como http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd e também especifica o LocalPart como UsernameToken.

    6. Opcional: Especifique o nome de configuração do módulo de login do JAAS. No lado do gerador, o tipo de configuração é sempre gerar (por exemplo, system.wss.generate.unt).
    7. Inclua o SecurityToken no WSSGenerationContext.
    8. Chame WSSGenerationContext.process() e gere o cabeçalho WS-Security.

Resultados

Se ocorrer uma condição de erro, uma WSSException será fornecida. Se bem-sucedido, o WSSGenerationContext process() é chamado e o token de segurança para a ligação do gerador é conectado.

Exemplo

O código de exemplo a seguir mostra como usar APIs WSS para criar um token de segurança Username, anexar o token Username à mensagem SOAP e configurar o token Username na ligação de gerador.

// import the packages
import javax.xml.ws.BindingProvider;
import com.ibm.websphere.wssecurity.wssapi.*;
import com.ibm.websphere.wssecurity.callbackhandler.*;
...
   // obter o provedor de ligação
   BindingProvider bp = ... ;

   // obter o contexto da solicitação
   Map<String, Object> reqContext = bp.getRequestContext();

   // gerar instância WSSFactory
   WSSFactory factory = WSSFactory.getInstance();

   // gerar instância do WSSGenerationContext
   WSSGenerationContext gencont = factory.newWSSGenerationContext();

   // gerar manipulador de retorno de chamada
   UNTGenerateCallbackHandler untCallbackHandler = 
   new UNTGenerateCallbackHandler("Chris", "sirhC");

   // gerar o token de nome do usuário 
   SecurityToken unt = factory.newSecurityToken(UsernameToken.class, untCallbackHandler);

   // incluir o SecurityToken no WSSGenerationContext
   gencont.add(unt);

   // gerar o cabeçalho WS-Security
   gencont.process(reqContext);
O código de exemplo a seguir mostra como modificar a amostra do token Username precedente para criar um token LTPAv2 a partir da identidade runAs no encadeamento atual. As duas linhas de código que instanciam o manipulador de retorno de chamada e criam o token de segurança são substituídas pelas duas linhas de código a seguir:
// generate callback handler
LTPAGenerateCallbackHandler ltpaCallbackHandler = new LTPAGenerateCallbackHandler(null, null);

// gerar o token LTPAv2 
SecurityToken ltpa = wssfactory.newSecurityToken(LTPAv2Token.class, ltpaCallbackHandler);

A instanciação do objeto LTPAGenerateCallbackHandler com (null, null) indica que o token LTPA deve ser gerado a partir da identidade runAs atual. Se o manipulador de retorno de chamada for instanciado com informações basicAuth, ("userName", "password"), um novo token LTPA será criado usando as informações basicAuth especificadas.

O exemplo a seguir mostra como utilizar a conversação segura com as WSS APIs para configurar os tokens do gerador, assim como os tokens do consumidor. Neste exemplo, o token SecurityContextToken é criado utilizando-se o espaço de nomes de rascunho do WS-SecureConversation: http://schemas.xmlsoap.org/ws/2005/02/sc/sct. Para utilizar o espaço de nomes WS-SecureConversation versão 1.3, http://docs.oasis-open.org/ws-sx/ws-secureconversation/200512/sct, especifique SecurityContextToken13.class em vez de SecurityContextToken.class.
// import the packages
import javax.xml.ws.BindingProvider;
import com.ibm.websphere.wssecurity.wssapi.*;
import com.ibm.websphere.wssecurity.callbackhandler.*;
...
   // obter o provedor de ligação
   BindingProvider bp = ... ;

   // obter o contexto da solicitação
   Map<String, Object> reqContext = bp.getRequestContext();

   // gerar instância WSSFactory
   WSSFactory wssFactory = WSSFactory.getInstance();

   WSSGenerationContext bootstrapGenCon = wssFactory.newWSSGenerationContext();

   // Criar um Registro de Data e Hora
   ...
   // Incluir registro de data e hora
   ...

   // Assinar o Corpo SOAP, os cabeçalhos do WS-Addressing e o Registro de Data e Hora
   X509GenerateCallbackHandler btspReqSigCbHandler = new X509GenerateCallbackHandler(...);
   SecurityToken btspReqSigToken = wssFactory.newSecurityToken(X509Token.class,
                                                               btspReqSigCbHandler);
   WSSSignature bootstrapReqSig = wssFactory.newWSSSignature(btspReqSigToken);
   bootstrapReqSig.setCanonicalizationMethod(WSSSignature.EXC_C14N);

   // Incluir Partes de Assinatura
   ...
   bootstrapGenCon.add(bootstrapReqSig);

   // Criptografar o Corpo SOAP e a Assinatura
   X509GenerateCallbackHandler btspReqEncCbHandler = new X509GenerateCallbackHandler(...);
   SecurityToken btspReqEncToken = wssFactory.newSecurityToken(X509Token.class,
                                                               btspReqEncCbHandler);
   WSSEncryption bootstrapReqEnc = wssFactory.newWSSEncryption(btspReqEncToken);
   bootstrapReqEnc.setEncryptionMethod(WSSEncryption.AES128);
   bootstrapReqEnc.setKeyEncryptionMethod(WSSEncryption.KW_RSA15);

   // Incluir Partes de Criptografia
   ...
   bootstrapGenCon.add(bootstrapReqEnc);
   WSSConsumingContext bootstrapConCon = wssFactory.newWSSConsumingContext();
   X509ConsumeCallbackHandler btspRspVfyCbHandler = new X509ConsumeCallbackHandler(....);
   WSSVerification bootstrapRspVfy = wssFactory.newWSSVerification(X509Token.class,
                                                                   btspRspVfyCbHandler);
   bootstrapRspVfy.addAllowedCanonicalizationMethod(WSSVerification.EXC_C14N);

   // Incluir Partes de Verificação
   ...
   bootstrapConCon.add(bootstrapRspVfy);
   X509ConsumeCallbackHandler btspRspDecCbHandler = new X509ConsumeCallbackHandler(...);
   WSSDecryption bootstrapRspDec = wssFactory.newWSSDecryption(X509Token.class,
                                                               btspRspDecCbHandler);
   bootstrapRspDec.addAllowedEncryptionMethod(WSSDecryption.AES128);
   bootstrapRspDec.addAllowedKeyEncryptionMethod(WSSDecryption.KW_RSA15);

   // Incluir Partes de Decriptografia
   ...
   bootstrapConCon.add(bootstrapRspDec);
   SCTGenerateCallbackHandler sctgch = new SCTGenerateCallbackHandler(bootstrapGenCon,
                                                                      bootstrapConCon,
                                                                      ENDPOINT_URL,
                                                                      WSSEncryption.AES128);
   SecurityToken[] scts = wssFactory.newSecurityTokens(new Class[]{SecurityContextToken.class}, sctgch);
   SecurityContextToken sct = (SecurityContextToken)scts[0];

   // Utilizar o SCT para gerar DKTs para a Conversação Segura
   // Algoritmo de assinatura e rótulos de cliente e serviço
   DerivedKeyToken dktSig = sct.getDerivedKeyToken(WSSSignature.HMAC_SHA1, "WS-SecureConversation", "WS-SecureConversation");

   // Algoritmo de criptografia e rótulos de cliente e serviço
   DerivedKeyToken dktEnc = sct.getDerivedKeyToken(WSSEncryption.AES128, "WS-SecureConversation", "WS-SecureConversation");

   // Criar o contexto de geração de aplicativo para a mensagem de pedido
   WSSGenerationContext applicationGenCon = wssFactory.newWSSGenerationContext();

   // Criar e incluir Registro de Data e Hora
   ...

   // Incluir o token de chave derivado e Assinar o Corpo SOAP e cabeçalhos WS-Addressing
   WSSSignature appReqSig = wssFactory.newWSSSignature(dktSig);
   appReqSig.setSignatureMethod(WSSSignature.HMAC_SHA1);
   appReqSig.setCanonicalizationMethod(WSSSignature.EXC_C14N);
   ...
   applicationGenCon.add(appReqSig);

   // Incluir o token de chave derivado e Criptografar o Corpo SOAP e a Assinatura
   WSSEncryption appReqEnc = wssFactory.newWSSEncryption(dktEnc);
   appReqEnc.setEncryptionMethod(WSSEncryption.AES128);
   appReqEnc.setTokenReference(SecurityToken.REF_STR);
   appReqEnc.encryptKey(false);
   ...
   applicationGenCon.add(appReqEnc);

   // Criar o contexto de consumo de aplicativo para a mensagem de resposta
   WSSConsumingContext applicationConCon = wssFactory.newWSSConsumingContext();

   //etiquetas de cliente e serviço e algoritmo de decriptografia
   SCTConsumeCallbackHandler sctCbHandler = new SCTConsumeCallbackHandler("WS-SecureConversation", "WS-SecureConversation", WSSDecryption.AES128);

   // Derivar o token do SCT e utilizá-lo para Decriptografar o Corpo SOAP e a Assinatura
   WSSDecryption appRspDec = wssFactory.newWSSDecryption(SecurityContextToken.class,
                                                         sctCbHandler);
   appRspDec.addAllowedEncryptionMethod(WSSDecryption.AES128);
   appRspDec.encryptKey(false);
   ...
   applicationConCon.add(appRspDec);

   // Derivar o token a partir de SCT e usá-lo para Verificar a
   // assinatura no Corpo SOAP, cabeçalhos WS-Addressing e Registro de Data e Hora
   WSSVerification appRspVfy = wssFactory.newWSSVerification(SecurityContextToken.class,
                                                             sctCbHandler);
   ...
   applicationConCon.add(appRspVfy);
   ...
   applicationGenCon.process(reqContext);
   applicationConCon.process(reqContext);

O que Fazer Depois

Para cada tipo de token, configure o token utilizando as WSS APIs ou utilizando o console administrativo. Em seguida, especifique os tokens do consumidor semelhantes, se isso não foi feito.

Se os tokens do gerador e do consumidor estiverem configurados, continue protegendo as mensagens SOAP, assinando a mensagem SOAP ou criptografando a mensagem, conforme necessário. É possível utilizar as WSS APIs ou o console administrativo para proteger as mensagens SOAP.


Ícone que indica o tipo de tópico Tópico de Tarefa



Ícone de registro de data e hora Última atualização: last_date
http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=twbs_confwssgeneratortoken
Nome do arquivo: twbs_confwssgeneratortoken.html