Criptografando a Mensagem SOAP Usando a API WSSEncryption

É possível proteger as mensagens SOAP, sem usar os conjuntos de política para configuração, utilizando as WSS APIs (Web Services Security APIs). Para configurar o cliente para a criptografia de pedido no gerador, use a API WSSEncryption para criptografar a mensagem SOAP. A API WSSEncryption especifica quais partes da mensagem SOAP do pedido serão criptografadas ao configurar o cliente.

Antes de Iniciar

É possível usar a API WSS ou os conjuntos de políticas no console administrativo para ativar a criptografia e incluir tokens de segurança do gerador na mensagem SOAP. Para oferecer segurança às mensagens SOAP, use as APIs WSS para concluir as seguintes tarefas de criptografia, conforme necessário:

  • Configure a criptografia e escolha os métodos de criptografia utilizando a API WSSEncryption.
  • Configure as partes criptografadas, conforme necessário, usando a API WSSEncryptPart.

Sobre Esta Tarefa

As informações de criptografia no gerador são usadas para criptografar uma mensagem SOAP enviada para ligações do gerador de pedido (cliente). A configuração do gerador de cliente deve corresponder à configuração para o consumidor do provedor.

Usando a API WSSEncryption para criptografar uma mensagem SOAP de saída

As configurações de sigilo necessitam que as restrições de sigilo sejam aplicadas às mensagens geradas. Isso inclui a especificação de quais partes da mensagem gerada devem ser criptografadas e as partes da mensagem nas quais devem ser anexados os elementos Nonce e de registro de data e hora criptografados.

As seguintes partes da criptografia podem ser configuradas:

Tabela 1. Partes da Criptografia. Utilize as partes de criptografia para ativar a criptografia em mensagens.
Partes da Criptografia Descrição
part Inclui o objeto WSSEncryptPart como um destino da parte de criptografia.
keyword Inclui as partes da criptografia usando palavras-chave. O WebSphere Application Server suporta as seguintes palavras-chave:
  • BODY_CONTENT
  • SIGNATURE
xpath Inclui a parte de criptografia usando uma expressão XPath.
signature Inclui o componente WSSignature como um destino da parte criptografada.
header Inclui o cabeçalho SOAP, especificado por QName, como um destino da parte criptografada.
securityToken Inclui o objeto SecurityToken como um destino da parte criptografada.

Na criptografia, determinados comportamentos padrão ocorrem. A forma mais simples de usar a API WSSEncryption é usar o comportamento padrão (veja o código de exemplo).

WSSEncryption fornece padrões para o algoritmo de criptografia de chaves, o algoritmo de criptografia de dados e o método de referência do token de segurança e as partes da criptografia, como a assinatura e o conteúdo do corpo de SOAP. Os comportamentos padrão da criptografia incluem:

Tabela 2. Decisões da Criptografia. Utilize o comportamento padrão de criptografia para proteger a assinatura e o conteúdo do corpo da mensagem.
Decisões da Criptografia Comportamento Padrão
Quais partes da mensagem SOAP criptografar utilizando as palavras-chave

Configura as partes da criptografia que você pode incluir usando palavras-chave. As partes padrão da criptografia são BODY_CONTENT e SIGNATURE. O WebSphere Application Server suporta o uso destas palavras-chave:

  • WSSEncryption.BODY_CONTENT
  • WSSEncryption.SIGNATURE
Qual método de criptografia de dados escolher (algorithm)

Configura o método de criptografia de dados. Os métodos de criptografia de dados e chave podem ser especificados. O método do algoritmo de criptografia de dados padrão é AES 128. O WebSphere Application Server suporta estes métodos de criptografia de dados:

  • WSSEncryption.AES128: http://www.w3.org/2001/04/xmlenc#aes128-cbc
  • WSSEncryption.AES192: http://www.w3.org/2001/04/xmlenc#aes192-cbc
  • WSSEncryption.AES256: http://www.w3.org/2001/04/xmlenc#aes256-cbc
  • WSSEncryption.TRIPLE_DES: http://www.w3.org.2001/04/xmlenc#tripledes-cbc
Criptografar ou não a chave (isEncrypt)

Especifica se a chave será ou não criptografada. Os valores são true ou false. O valor padrão é criptografar a chave (true).

Qual método de criptografia de chaves escolher (algorithm)

Configura o método de criptografia de chaves. Os métodos de criptografia de dados e chave podem ser especificados. O método do algoritmo de criptografia de chaves padrão é o agrupamento de chaves RSA OAEP. O WebSphere Application Server suporta estes métodos de criptografia de chaves:

  • WSSEncryption.KW_AES128: http://www.w3.org/2001/04/xmlenc#kw-aes128
  • WSSEncryption.KW_AES192: http://www.w3.org/2001/04/xmlenc#kw-aes192
  • WSSEncryption.KW_AES256: http://www.w3.org/2001/04/xmlenc#kw-aes256
  • WSSEncryption.KW_RSA_OAEP: http://www.w3.org/2001/04/xmlenc#rsa-oaep-mgf1p
  • WSSEncryption.KW_RSA15: http://www.w3.org/2001/04/xmlenc#rsa-1_5
  • WSSEncryption.KW_TRIPLE_DES: http://www.w3.org/2001/04/xmlenc#kw-tripledes
Qual token de segurança especificar (securityToken)

Configura SecurityToken. O tipo de token de segurança padrão é X509Token. O WebSphere Application Server fornece os seguintes tipos de token de consumidor pré-configurados:

  • Token de chave derivado
  • Tokens X.509
Qual referência de token usar (refType) Configura o tipo de referência do token de segurança. A referência do token de segurança padrão é SecurityToken.REF_KEYID. O WebSphere Application Server suporta os seguintes tipos de referência de token:
  • SecurityToken.REF_KEYID
  • SecurityToken.REF_STR
  • SecurityToken.REF_EMBEDDED
  • SecurityToken.REF_THUMBPRINT
Usar ou não MTOM (mtomOptimize) Configura a otimização do MTOM (Message Transmission Optimization Mechanism) para a parte criptografada.

Procedimento

  1. Para criptografar a mensagem SOAP utilizando a API WSSEncryption, primeiro assegure-se de que o servidor de aplicativos esteja instalado.
  2. O processo da API WSS para criptografia desempenha estas etapas:
    1. Usa WSSFactory.getInstance() para obter a instância de implementação da API WSS
    2. Cria a instância WSSGenerationContext a partir da instância WSSFactory.
    3. Cria SecurityToken a partir de WSSFactory usado para criptografia.
    4. Cria WSSEncryption a partir da instância WSSFactory usando SecurityToken. O comportamento padrão de WSSEncryption é criptografar a assinatura e o conteúdo do corpo.
    5. Inclui uma nova parte para ser criptografada em WSSEncryption, se a parte existente não for adequada. Depois que addEncryptPart(), addEncryptHeader() ou addEncryptPartByXPath() for chamada, a parte padrão será limpa.
    6. Chama encryptKey(false), se a chave não for criptografada.
    7. Configura o método de criptografia de dados, se o método padrão não for adequado.
    8. Configura o método de criptografia de chaves, se o método padrão não for adequado.
    9. Configura a referência de token, se a referência de token padrão não for adequada.
    10. Inclui WSSEncryption em WSSConsumingContext.
    11. Chama WSSGenerationContext.process() com SOAPMessageContext.

Resultados

Se houver uma condição de erro durante a criptografia, WSSException será fornecida. Se ocorrer êxito, a API chamará o WSSGenerationContext.process(), o cabeçalho da Segurança WS será gerado, e a mensagem SOAP agora estará protegida usando a Segurança de Serviços da Web.

Exemplo

O seguinte exemplo fornece o código de amostra que usa métodos que são definidos em WSSEncryption:

// Obter o contexto da mensagem
   Object msgcontext = getMessageContext();

// Gerar a instância WSSFactory (etapa: a)
WSSFactory factory = WSSFactory.getInstance();		

// Gerar a instância WSSGenerationContext (etapa: b)
WSSGenerationContext gencont = factory.newWSSGenerationContext();

// Gerar o manipulador de retorno de chamada
X509GenerateCallbackHandler callbackHandler = new 
         X509GenerateCallbackHandler(
			  "",
			  "enc-sender.jceks",
			  "jceks", 
			  "storepass".toCharArray(), 
			  "bob", 
			  null, 
			  "CN=Bob, O=IBM, C=US", 
			  null);

// Gerar o token de segurança usado para criptografia (etapa: c)
SecurityToken token = factory.newSecurityToken(X509Token.class , callbackHandler);

// Gerar a instância WSSEncryption (etapa: d)
WSSEncryption enc = factory.newWSSEncryption(token);

// Configurar a parte a ser criptografada (etapa: e)
// PADRÃO: WSSEncryption.BODY_CONTENT e WSSEncryption.SIGNATURE

// Configurar a parte especificada pela palavra-chave (etapa: e)
   enc.addEncryptPart(WSSEncryption.BODY_CONTENT);

// Configurar a parte no cabeçalho de SOAP especificado por QName (etapa: e)
   enc.addEncryptHeader(new QName("http://www.w3.org/2005/08/addressing",
                                  "MessageID"));

// Configurar a parte especificada por WSSSignature (etapa: e)
   SecurityToken sigToken = getSecurityToken();
      WSSSignature sig = factory.newWSSSignature(sigToken);
   enc.addEncryptPart(sig);

// Configurar a parte especificada por SecurityToken (etapa: e)
   UNTGenerateCallbackHandler untCallbackHandler = 
	         new UNTGenerateCallbackHandler("Chris", "sirhC");		
      SecurityToken unt = factory.newSecurityToken(UsernameToken.class, 
                                                   untCallbackHandler);
   enc.addEncryptPart(unt, false);

// Configurar a parte especificada pela expressão XPath (etapa: e)
   StringBuffer sb = new StringBuffer();
      sb.append("/*[namespace-uri()='http://schemas.xmlsoap.org/soap/envelope/' 
         e local-name()='Envelope']");
      sb.append("/*[namespace-uri()='http://schemas.xmlsoap.org/soap/envelope/' 
         e local-name()='Body']");
      sb.append("/*[namespace-uri()='http://xmlsoap.org/Ping' 
         e local-name()='Ping']");
      sb.append("/*[namespace-uri()='http://xmlsoap.org/Ping' 
         e local-name()='Text']");
   enc.addEncryptPartByXPath(sb.toString());

// Configurar se a chave será ou não criptografada (etapa: f)
// PADRÃO: true
   enc.encryptKey(true);

// Configurar o método de criptografia de dados (etapa: g)
// DEFAULT: WSSEncryption.AES128
   enc.setEncryptionMethod(WSSEncryption.TRIPLE_DES);

// Configurar o método de criptografia de chaves (etapa: h)
// DEFAULT: WSSEncryption.KW_RSA_OAEP
   enc.setEncryptionMethod(WSSEncryption.KW_RSA15);

// Configurar a referência do token (etapa: i)
// PADRÃO: SecurityToken.REF_KEYID 
	 enc.setTokenReference(SecurityToken.REF_STR);

// Incluir WSSEncryption em WSSGenerationContext (etapa: j)
  gencont.add(enc);

// Processar o cabeçalho de WS-Security (etapa: k)
gencont.process(msgcontext);
Nota: X509GenerationCallbackHandler não precisa da senha da chave porque a chave pública é usada para criptografia. Você não precisa de uma senha para obter a chave pública do armazenamento de chaves Java™.

O que Fazer Depois

Se você não tiver especificado anteriormente quais métodos de criptografia escolher, use a API WSS ou configure os conjuntos de políticas usando o console administrativo para escolher os métodos do algoritmo de criptografia de dados e chaves.


Í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_confwssencryption
Nome do arquivo: twbs_confwssencryption.html