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:
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:
WebSphere Application Server también proporciona los siguientes tipos de señal de generador preconfigurados para la autenticidad del mensaje:
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:
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:
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 |
- 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
Resultados
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);
// 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.
// 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.