Configuración de las señales de seguridad del generador mediante la API WSS

Puede proteger los mensajes SOAP, sin utilizar conjuntos de políticas, utilizando las API de Web Services Security. Para configurar la señal en el lado del generador, utilice las API WSS (Web Services Security). Las señales de seguridad del generador forman parte del paquete de la interfaz de com.ibm.websphere.wssecurity.wssapi.token.

Antes de empezar

La infraestructura de la señal conectable en WebSphere Application Server ha sido rediseñada para que se pueda reutilizar la misma infraestructura desde la API de WSS. Se puede utilizar la misma implementación de creación y validación de la señal de seguridad para la ejecución de Web Services Security y también para el código de aplicación de la API WSS. Asimismo, la infraestructura rediseñada simplifica el modelo de programación de la SPI y la hará más fácil para añadir tipos de señal de seguridad.

Puede utilizar la API WSS o puede configurar las señales utilizando la consola administrativa. Para configurar las señales, debe completar las siguientes tareas de señal:

  • Configurar las señales del generador.
  • Configurar las señales del consumidor.

Acerca de esta tarea

CallbackHandler de JAAS y LoginModule de JAAS son responsables de crear la señal de seguridad en el lado del generador.

En el lado del generador, se crea la señal utilizando LoginModule de JAAS y CallbackHandler de JAAS para pasar los datos de autenticación. A continuación, LoginModule de JAAS crea el objeto securityToken, como UsernameToken, y lo pasa al tiempo de ejecución de Web Services Security.

En el lado del consumidor, el formato XML se pasa a LoginModule de JAAS para la validación o autenticación. A continuación, se utiliza CallbackHandler de JAAS para pasar datos de autenticación de la ejecución de Web Services Security a LoginModule. Una vez que se ha autenticado la señal, se crea un objeto de señal de seguridad y la señal se pasa al tiempo de ejecución de Web Services Security.

Cuando se utiliza la API de WSS para la creación de la señal del generador, se producen determinados comportamientos predeterminados. La forma más fácil de utilizar la API WSS es utilizar el comportamiento predeterminado (consulte el código de ejemplo). La API WSS proporciona valores predeterminados para el tipo de señal, el valor de la señal y el nombre de confirmación de JAAS. Los comportamientos predeterminados de la señal incluyen:

Tabla 1. Decisiones de señal y comportamientos predeterminados. De manera predeterminada se configuran varias características.
Decisiones de la señal del generador Comportamiento predeterminado
Qué tipo de señal utilizar

El tipo de señal especifica qué tipo de señal utilizar para la integridad, la confidencialidad o la autenticidad del mensaje.

WebSphere Application Server proporciona los siguientes tipos de señal del generador preconfigurados para la integridad y la confidencialidad del mensaje:
  • Señal de clave derivada
  • Señales X509
También puede crear tipos de señal personalizados, según sea necesario.

WebSphere Application Server también proporciona los siguientes tipos de señal de generador preconfigurados para la autenticidad del mensaje:

  • Señal de nombre de usuario
  • Señales LTPA
  • Señales X509

También puede crear tipos de señal personalizados, según sea necesario.

Qué nombre de configuración de inicio de sesión de JAAS especificar

El nombre de configuración del inicio de sesión de JAAS especifica qué nombre de configuración de inicio de sesión de JAAS se va a utilizar.

Qué tipo de configuración utilizar El módulo JAAS especifica el tipo de configuración. Para los tipos de señal de generador sólo se pueden utilizar los tipos de configuración de generador preconfigurados.

La clase SecurityToken (com.ibm.websphere.wssecurity.wssapi.token.SecurityToken) es la clase de señal genérica y representa la señal de seguridad que tiene métodos para obtener la identidad, el formato XML y las claves criptográficas. Al utilizar la clase de la señal de seguridad, puede aplicar tanto la firma como el cifrado al mensaje SOAP. Sin embargo, para aplicar ambas cosas, debe tener dos objetos SecurityToken, uno para la firma y otro para el cifrado, respectivamente.

Los tipos de señal siguientes son subclases de la clase de señal de seguridad genérica:

Tabla 2. Subclases de SecurityToken. Utilice las subclases para representar la señal de seguridad.
Tipo de señal Nombre de la configuración del inicio de sesión de JAAS
Señal de nombre de usuario system.wss.generate.unt
Señal de contexto de seguridad system.wss.generate.sct
Señal de clave derivada system.wss.generate.dkt

Los tipos de señal siguientes son subclases de la clase de señal de seguridad binaria:

Tabla 3. Subclases de BinarySecurityToken. Utilice las subclases para representar la señal de seguridad binaria.
Tipo de señal Nombre de la configuración del inicio de sesión de JAAS
Señal LTPA system.wss.generate.ltpa
Señal de propagación de LTPA system.wss.generate.ltpaProp
Señal X.509 system.wss.generate.x509
Señal de vía de acceso de PKI X.509 system.wss.generate.pkiPath
Señal PKCS7 X.509 system.wss.generate.pkcs7
Nota:
  • Para cada nombre de configuración de la señal de inicio de sesión de JAAS, existe un nombre de configuración del consumidor de señales respectivo. Por ejemplo, para la señal Username, el nombre de configuración del consumidor de señales respectivo es system.wss.consume.unt.
  • LTPA y las señales de propagación de LTPA sólo están disponibles en un solicitante que se ejecuta como un cliente basado en servidor. LTPA y las señales de propagación LTPA no están soportados para Java™ SE 6 o para el cliente de aplicación Java EE.

Procedimiento

  1. Para configurar el paquete securityToken, com.ibm.websphere.wssecurity.wssapi.token, en primer lugar, asegúrese de que está instalado el servidor de aplicaciones.
  2. Utilice el proceso del generador de señales de Web Services Security para configurar las señales: Para cada tipo de señal, el proceso es similar al proceso siguiente que demuestra el proceso del generador de señales UsernameToken:
    1. Utilice WSSFactory.getInstance() para obtener la instancia de implementación de la API de WSS.
    2. Cree la instancia WSSGenerationContext desde la instancia WSSFactory.
    3. Cree un CallbackHandler de JAAS. Los datos de autenticación como, por ejemplo, el nombre de usuario y la contraseña se especifican como parte del CallbackHandler. Por ejemplo, el código siguiente especifica Chris como el nombre de usuario y sirhC como la contraseña: UNTGenerationCallbackHandler("Chris", "sirhC");
    4. Llame a cualquier parámetro de CallbackHandler de JAAS y revise la información de la clase de señal para la cual los parámetros son necesarios u opcionales. Por ejemplo, para el UsernameToken, también se pueden configurar los parámetros siguientes:
      Nonce
      Indica si se incluye un parámetro nonce en la señal de nombre de usuario para el generador de señales. Nonce es un número criptográfico exclusivo que se incorpora en un mensaje para facilitar la detención de repetidos ataques no autorizados de señales de nombre de usuario. El valor nonce sólo es válido, cuando el tipo de señal generada es UsernameToken y sólo si se aplica al enlace del generador de la solicitud.
      Indicación de fecha y hora creada
      Indica si se va a insertar una indicación de fecha y hora en la señal UsernameToken. El valor timestamp sólo es válido cuando el tipo de señal generada es un UsernameToken y sólo si se aplica al enlace del generador de la solicitud.
    5. Cree el SecurityToken a partir de WSSFactory.

      De forma predeterminada, la API UsernameToken especifica el tipo ValueType como: "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#UsernameToken"

      De forma predeterminada, la API UsernameToken proporciona el QName de esta clase y especifica el NamespaceURI como http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd y también especifica la LocalPart como UsernameToken.

    6. Opcional: Especifique el nombre de configuración del módulo de inicio de sesión JAAS. En el lado del generador, el tipo de configuración siempre es generate (por ejemplo, system.wss.generate.unt).
    7. Añada el SecurityToken a WSSGenerationContext.
    8. Llame a WSSGenerationContext.process() y genere la cabecera de WS-Security.

Resultados

Si se produce una condición de error, se proporciona una excepción WSSException. Si es correcto, se llama a WSSGenerationContext process() y se conecta la señal de seguridad para el enlace del generador.

Ejemplo

El siguiente código de ejemplo muestra cómo utilizar las API de WSS para crear una señal de seguridad Username, conectar la señal Username al mensaje SOAP y configurar la señal Username con el enlace del generador.

// importar los paquetes
import javax.xml.ws.BindingProvider;
import com.ibm.websphere.wssecurity.wssapi.*;
import com.ibm.websphere.wssecurity.callbackhandler.*;
...
   // obtener el proveedor de enlaces
   BindingProvider bp = ... ;

   // obtener el contexto de solicitud
   Map<String, Object> reqContext = bp.getRequestContext();

   // generar la instancia WSSFactory
   WSSFactory factory = WSSFactory.getInstance();

   // generar la instancia de WSSGenerationContext
   WSSGenerationContext gencont = factory.newWSSGenerationContext();

   // generar el manejador de retorno de llamada
   UNTGenerateCallbackHandler untCallbackHandler = 
   	         new UNTGenerateCallbackHandler("Chris", "sirhC");		

   // generar la señal username (nombre de usuario) 
   SecurityToken unt = factory.newSecurityToken(UsernameToken.class, untCallbackHandler);

   // añadir SecurityToken a WSSGenerationContext
   gencont.add(unt);

   // generar la cabecera de WS-Security
   gencont.process(reqContext);
El siguiente código de ejemplo muestra cómo modificar el ejemplo de señal Username anterior para crear una señal LTPAv2 desde la identidad runAs en la hebra actual. Las dos líneas de código que crean una instancia del manejador de devolución de llamada y crean la señal de seguridad se sustituyen por las siguientes dos líneas de código:
// generar el manejador de devolución de llamada
LTPAGenerateCallbackHandler ltpaCallbackHandler = new LTPAGenerateCallbackHandler(null, null);

// generar la señal LTPAv2
SecurityToken ltpa = wssfactory.newSecurityToken(LTPAv2Token.class, ltpaCallbackHandler);

La instanciación del objeto LTPAGenerateCallbackHandler con (null, null) indica que la señal LTPA se debería generar a partir de la identidad runAs actual. Si el manejador de devolución de llamada crea una instancia con la información basicAuth, ("nombreUsuario", "contraseña"), se creará una nueva señal LTPA utilizando la información basicAuth especificada.

En el siguiente ejemplo se muestra cómo utilizar Secure Conversation con las API de WSS para configurar las señales del generador, así como las señales del consumidor. En este ejemplo, se crea la señal SecurityContextToken utilizando el espacio de nombres de borrador WS-SecureConversation: http://schemas.xmlsoap.org/ws/2005/02/sc/sct. Para utilizar el espacio de nombres de WS-SecureConversation versión 1.3, http://docs.oasis-open.org/ws-sx/ws-secureconversation/200512/sct, especifique SecurityContextToken13.class en lugar de SecurityContextToken.class.
// importar los paquetes
import javax.xml.ws.BindingProvider;
import com.ibm.websphere.wssecurity.wssapi.*;
import com.ibm.websphere.wssecurity.callbackhandler.*;
...
   // obtener el proveedor de enlaces
   BindingProvider bp = ... ;

   // obtener el contexto de solicitud
   Map<String, Object> reqContext = bp.getRequestContext();

   // generar la instancia WSSFactory
   WSSFactory wssFactory = WSSFactory.getInstance();

   WSSGenerationContext bootstrapGenCon = wssFactory.newWSSGenerationContext();

   // Crear una indicación de fecha y hora
   ...
   // Añadir timestamp
   ...

   		// Firmar el cuerpo SOAP, las cabeceras WS-Addressing y la indicación de fecha y hora
   X509GenerateCallbackHandler btspReqSigCbHandler = new X509GenerateCallbackHandler(...);
   SecurityToken btspReqSigToken = wssFactory.newSecurityToken(X509Token.class,
                                                               btspReqSigCbHandler);
   		WSSSignature bootstrapReqSig = wssFactory.newWSSSignature(btspReqSigToken);
   		bootstrapReqSig.setCanonicalizationMethod(WSSSignature.EXC_C14N);

   // Añadir Firmar partes
   ...
   bootstrapGenCon.add(bootstrapReqSig);

   		// Cifrar el cuerpo SOAP y la firma
   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);

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

   // Añadir Verificar partes
   ...
   bootstrapConCon.add(bootstrapRspVfy);
   X509ConsumeCallbackHandler btspRspDecCbHandler = new X509ConsumeCallbackHandler(...);
   WSSDecryption bootstrapRspDec = wssFactory.newWSSDecryption(X509Token.class, btspRspDecCbHandler);
   bootstrapRspDec.addAllowedEncryptionMethod(WSSDecryption.AES128);
   		bootstrapRspDec.addAllowedKeyEncryptionMethod(WSSDecryption.KW_RSA15);

   // Añadir Partes de descifrado
   ...
   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 SCT para generar DKT para Secure Conversation
   // Algoritmo de firma y etiquetas de cliente y servicio
   DerivedKeyToken dktSig = sct.getDerivedKeyToken(WSSSignature.HMAC_SHA1,
                                                   "WS-SecureConversation",
                                                   "WS-SecureConversation");

   // Algoritmo de cifrado y etiquetas de cliente y servicio
   DerivedKeyToken dktEnc = sct.getDerivedKeyToken(WSSEncryption.AES128,
                                                   "WS-SecureConversation",
                                                   "WS-SecureConversation");

   // Cree el contexto de generación de aplicaciones para el mensaje de solicitud
   		WSSGenerationContext applicationGenCon = wssFactory.newWSSGenerationContext();

   // Crear y añadir la indicación de fecha y hora
   ...

   // Añadir la señal de clave derivada y firmar el cuerpo SOAP y las cabeceras WS-Addressing
   		WSSSignature appReqSig = wssFactory.newWSSSignature(dktSig);
   		appReqSig.setSignatureMethod(WSSSignature.HMAC_SHA1);
   		appReqSig.setCanonicalizationMethod(WSSSignature.EXC_C14N);
   ...
   		applicationGenCon.add(appReqSig);

   // añadir la señal de clave derivada y cifrar el cuerpo SOAP y la firma
   		WSSEncryption appReqEnc = wssFactory.newWSSEncryption(dktEnc);
   		appReqEnc.setEncryptionMethod(WSSEncryption.AES128);
   		appReqEnc.setTokenReference(SecurityToken.REF_STR);
   		appReqEnc.encryptKey(false);
   ...
   		applicationGenCon.add(appReqEnc);

   // Cree el contexto de consumo de aplicaciones para el mensaje de respuesta
   		WSSConsumingContext applicationConCon = wssFactory.newWSSConsumingContext();

   //etiquetas de cliente y servicio y algoritmo de descifrado
   SCTConsumeCallbackHandler sctCbHandler = new SCTConsumeCallbackHandler("WS-SecureConversation",
                                                                          "WS-SecureConversation",
                                                                          WSSDecryption.AES128);

   		// Derivar la señal de SCT y utilícela para descifrar el cuerpo SOAP y la firma
   WSSDecryption appRspDec = wssFactory.newWSSDecryption(SecurityContextToken.class,
                                                         sctCbHandler);
   		appRspDec.addAllowedEncryptionMethod(WSSDecryption.AES128);
   		appRspDec.encryptKey(false);
   ...
   		applicationConCon.add(appRspDec);

   // Derivar la señal de SCT y utilizarla para Verificar la
   // firma en el cuerpo SOAP, las cabeceras WS-Addressing y la indicación de fecha y hora
   WSSVerification appRspVfy = wssFactory.newWSSVerification(SecurityContextToken.class,
                                                             sctCbHandler);
   ...
   		applicationConCon.add(appRspVfy);
   ...
   applicationGenCon.process(reqContext);
   applicationConCon.process(reqContext);

Qué hacer a continuación

Para cada tipo de señal, configure la señal utilizando las API de WSS o la consola administrativa. A continuación, especifique las señales de consumidor similares, si todavía no lo ha hecho.

Si se configuran ambas señales, del generador y del consumidor, continúe protegiendo los mensajes SOAP firmando el mensaje SOAP o bien cifrando el mensaje, según sea necesario. Puede utilizar las API WSS o la consola administrativa para proteger los mensajes SOAP.


Icon that indicates the type of topic Task topic



Timestamp icon Last updated: last_date
http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=twbs_confwssgeneratortoken
File name: twbs_confwssgeneratortoken.html