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:
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:
O WebSphere Application Server também fornece os seguintes tipos de token de gerador pré-configurados para a autenticidade da mensagem:
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:
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:
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 |
- 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
Resultados
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);
// 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.
// 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.