WebSphere eXtreme Scale soporta la autorización JAAS (Java Authentication and Authorization Service) que está preparada para utilizarse y también soporta la autorización personalizada utilizando la interfaz ObjectGridAuthorization.
El plug-in ObjectGridAuthorization se utiliza para autorizar los accesos de ObjectGrid, ObjectMap y JavaMap a los principales representados por un objeto Subject de manera personalizada. Una implementación típica de este plug-in consiste en recuperar los principales del objeto Subject y, a continuación, comprobar si se otorgan a los principales los permisos especificados.
Un permiso pasado en el método checkPermission(Subject, Permission) puede ser uno de los permisos siguientes:
Consulte la documentación de la API ObjectGridAuthorization para obtener más información.
La clase pública com.ibm.websphere.objectgrid.security.MapPermission representa los permisos de los recursos de ObjectGrid, específicamente los métodos de interfaces ObjectMap o JavaMap. WebSphere eXtreme Scale define las siguientes series de permiso para acceder a los métodos de ObjectMap y JavaMap:
Consulte la documentación de la API MapPermission para obtener más información.
Puede construir un objeto MapPermission; para ello, pase el nombre de la correlación ObjectGrid totalmente calificado (con el formato [nombre_ObjectGrid].[nombre_ObjectMap]) y la serie de permiso o valor entero. Una serie de permiso puede ser una serie delimitada por comas de las series de permiso anteriores como leer, insertar, o todos ellos. Un valor entero de permiso puede ser cualquier constante entera de los permisos mencionados anteriormente o un valor matemático de varias constantes enteras de permisos, como MapPermission.READ|MapPermission.WRITE.
La autorización se produce cuando se llama al método ObjectMap o JavaMap. El tiempo de ejecución comprueba permisos distintos para métodos distintos. Si los permisos requeridos no se conceden al cliente, se produce una excepción AccessControlException.
Permiso | ObjectMap/JavaMap |
---|---|
leer | Boolean containsKey(Object) |
Boolean equals(Object) | |
Object get(Object) | |
Object get(Object, Serializable) | |
List getAll(List) | |
List getAll(List keyList, Serializable) | |
List getAllForUpdate(List) | |
List getAllForUpdate(List, Serializable) | |
Object getForUpdate(Object) | |
Object getForUpdate(Object, Serializable) | |
public Object getNextKey(long) | |
grabar | Object put(Object key, Object value) |
void put(Object, Object, Serializable) | |
void putAll(Map) | |
void putAll(Map, Serializable) | |
void update(Object, Object) | |
void update(Object, Object, Serializable) | |
insertar | public void insert (Object, Object) |
void insert(Object, Object, Serializable) | |
eliminar | Object remove (Object) |
void removeAll(Collection) | |
void clear() | |
invalidar | public void invalidate (Object, Boolean) |
void invalidateAll(Collection, Boolean) | |
void invalidateUsingKeyword(Serializable) | |
int setTimeToLive(int) |
La autorización se basa únicamente en el método utilizado y no en lo que el método hace. Por ejemplo, un método put puede insertar o actualizar un registro en función de si el registro existe. No obstante, los casos de inserción o actualización no se distinguen.
Puede conseguirse un tipo de operación mediante la combinación de otros tipos. Por ejemplo, una actualización puede conseguirse mediante una operación de eliminación primero, y después una inserción. Tenga en cuenta estas combinaciones al diseñar las políticas de autorización.
En la siguiente tabla se resumen los métodos y los ObjectGridPermission requeridos:
Acción de permiso | Métodos |
---|---|
consulta | com.ibm.websphere.objectgrid.Session.createObjectQuery(String) |
consulta | com.ibm.websphere.objectgrid.em.EntityManager.createQuery(String) |
dynamicmap | com.ibm.websphere.objectgrid.Session.getMap(String) |
ServerMapPermission representa permisos para ObjectMap alojado en un servidor. El nombre del permiso es el nombre completo del nombre de la correlación ObjectGrid. Tiene las acciones siguientes:
Acción de permiso | Métodos |
---|---|
replicar | com.ibm.websphere.objectgrid.ClientReplicableMap.enableClientReplication(Mode, int[], ReplicationMapListener) |
dynamicIndex | com.ibm.websphere.objectgrid.BackingMap.createDynamicIndex(String, Boolean, String, DynamicIndexCallback) |
dynamicIndex | com.ibm.websphere.objectgrid.BackingMap.removeDynamicIndex(String) |
Un AgentPermission representa permisos para los agentes de datagrid. El nombre del permiso es el nombre completo de la correlación ObjectGrid, y la acción es una serie delimitada por comas de los nombres de clase o nombres de paquete de la implementación del agente.
Consulte la documentación de la API AgentPermission si desea más información.
com.ibm.websphere.objectgrid.datagrid.AgentManager#callMapAgent(MapGridAgent, Collection)
com.ibm.websphere.objectgrid.datagrid.AgentManager#callMapAgent(MapGridAgent)
com.ibm.websphere.objectgrid.datagrid.AgentManager#callReduceAgent(ReduceGridAgent, Collection)
com.ibm.websphere.objectgrid.datagrid.AgentManager#callReduceAgent(ReduceGridAgent, Collection)
WebSphere eXtreme Scale soporta dos tipos de mecanismos de autorización: la autorización JAAS (Java Authentication and Authorization Service) y la autorización personalizada. Estos mecanismos se aplican a todas las autorizaciones. La autorización JAAS aumenta las políticas de seguridad Java con controles de acceso centrados en el usuario. Los permisos se conceden no sólo en función del código que se ejecute, sino en función de quién lo ejecute. La autorización JAAS forma parte de SDK versión 5 y posterior.
De forma adicional, WebSphere eXtreme Scale también soporta la autorización personalizada con el siguiente plug-in:
Puede implementar su propio mecanismo de autorización si no desea utilizar la autorización JAAS. Mediante el uso de un mecanismo de autorización personalizado, puede utilizar la base de datos de políticas, o Tivoli Access Manager para gestionar las autorizaciones.
Puede configurar el mecanismo de autorización de dos maneras:
Puede utilizar el archivo XML ObjectGrid para definir un ObjectGrid y establecer el mecanismo de autorización en AUTHORIZATION_MECHANISM_JAAS o AUTHORIZATION_MECHANISM_CUSTOM. A continuación se muestra el archivo secure-objectgrid-definition.xml que se utiliza en ObjectGridSample de aplicación de empresa:
<objectGrids>
<objectGrid name="secureClusterObjectGrid" securityEnabled="true"
authorizationMechanism="AUTHORIZATION_MECHANISM_JAAS">
<bean id="TransactionCallback"
classname="com.ibm.websphere.samples.objectgrid.HeapTransactionCallback" />
...
</objectGrids>
Si desea crear un ObjectGrid mediante un método ObjectGrid.setAuthorizationMechanism(int), puede llamar al método siguiente para establecer el mecanismo de autorización. La llamada a este método sólo se aplica al modelo de programación de WebSphere eXtreme Scale local cuando se crea directamente una instancia de ObjectGrid:
/**
* Establecer mecanismo de autorización. El valor predeterminado es
* com.ibm.websphere.objectgrid.security.SecurityConstants.
* AUTHORIZATION_MECHANISM_JAAS.
* @param authMechanism El mecanismo de autorización de correlación
*/
void setAuthorizationMechanism(int authMechanism);
Autorización JAAS
Un objeto javax.security.auth.Subject representa un usuario autenticado. Subject consta de un conjunto de principales y cada principal representa una identidad para ese usuario. Por ejemplo, Subject puede tener un principal de nombre, por ejemplo, Cristina López, y un principal de grupo, por ejemplo, gestor.
Si usa la política de autorización JAAS, los permisos se pueden conceder a principales específicos. WebSphere eXtreme Scale asocia el Subject con el contexto de control de accesos actual. Para cada llamada al método ObjectMap o Javamap, el tiempo de ejecución de Java determina automáticamente si la política otorga el permiso necesario sólo a un Principal específico y, de esta forma, la operación sólo está permitida si el Subject asociado al contexto de control de accesos contiene el Principal designado.
Debe estar familiarizado con la sintaxis de la política del archivo de políticas. Si desea obtener una descripción detallada de la autorización JAAS, consulte la publicación JAAS Reference Guide.
WebSphere eXtreme Scale tiene una base de código especial que se utiliza para comprobar la autorización JAAS para las llamadas a los métodos ObjectMap y JavaMap. Esta base de código especial es http://www.ibm.com/com/ibm/ws/objectgrid/security/PrivilegedAction. Utilice esta base de código al conceder permisos ObjectMap o JavaMap a los principales. Este código especial se creó porque el archivo JAR (Java Archive) para eXtreme Scale se otorga con todos los permisos.
La plantilla de la política para conceder el permiso MapPermission es:
grant codeBase "http://www.ibm.com/com/ibm/ws/objectgrid/security/PrivilegedAction"
<Principal field(s)>{
permission com.ibm.websphere.objectgrid.security.MapPermission
"[ObjectGrid_name].[ObjectMap_name]", "action";
....
permission com.ibm.websphere.objectgrid.security.MapPermission
"[ObjectGrid_name].[ObjectMap_name]", "action";
};
Un campo de principal se parece al ejemplo siguiente:principal Principal_class "principal_name"
En esta política, sólo se otorgan los permisos de inserción y lectura a estas cuatro correlaciones a un principal determinado. El otro archivo de políticas, fullAccessAuth.policy, otorga a un principal todos los permisos a estas correlaciones. Antes de ejecutar la aplicación, cambie el nombre del principal (principal_name) y la clase del principal por los valores correspondientes. El valor de principal_name depende del Registro de usuarios. Por ejemplo, si se utiliza el sistema operativo local como registro de usuarios, el nombre de máquina es MACH1, el ID de usuario es user1 y el nombre de principal es MACH1/user1.
La política de autorización JAAS se puede colocar directamente en el archivo de políticas Java, o se puede colocar en un archivo de autorización JAAS separado y, a continuación, establecerlo de cualquiera de estas dos maneras:
-Djava.security.auth.policy=file:[JAAS_AUTH_POLICY_FILE]
-Dauth.policy.url.x=file:[JAAS_AUTH_POLICY_FILE]
Autorización personalizada ObjectGrid
El plug-in ObjectGridAuthorization se utiliza para autorizar el acceso de ObjectGrid, ObjectMap y JavaMap a los principales, representados por un objeto Subject de una manera personalizada. Una implementación típica de este plug-in es recuperar los principales del objeto Subject y después comprobar si se han concedido los permisos especificados a los principales.
Un permiso pasado al método checkPermission(Subject, Permission) puede ser uno de los siguientes:
Consulte la documentación de la API ObjectGridAuthorization para obtener más información.
El plug-in ObjectGridAuthorization puede configurarse de las siguientes maneras:
Puede utilizar el archivo XML ObjectGrid para definir un plug-in ObjectAuthorization. Ejemplo:
<objectGrids>
<objectGrid name="secureClusterObjectGrid" securityEnabled="true"
authorizationMechanism="AUTHORIZATION_MECHANISM_CUSTOM">
...
<bean id="ObjectGridAuthorization"
className="com.acme.ObjectGridAuthorizationImpl" />
</objectGrids>
Si desea crear un ObjectGrid mediante el método de API ObjectGrid.setObjectGridAuthorization(ObjectGridAuthorization), puede llamar al método siguiente para establecer el plug-in de autorización. Este método sólo se aplica al modelo de programación eXtreme Scale local cuando cree directamente la instancia de ObjectGrid.
/**
* Establece <code>ObjectGridAuthorization</code> para esta
instancia de ObjectGrid.
* <p>
* Al pasar <code>null</code> a este método elimina un objeto
* <code>ObjectGridAuthorization</code> establecido
anteriormente de una invocación anterior de este método
* e indica que este <code>ObjectGrid</code> no está asociado a un
* objeto <code>ObjectGridAuthorization</code>.
* <p>
* Este método sólo debe utilizarse cuando se ha habilitado la seguridad
ObjectGrid. Si
* la seguridad ObjectGrid está inhabilitada, el objeto
<code>ObjectGridAuthorization</code> proporcionado
* no se utilizará.
* <p>
* Puede utilizarse un plug-in <code>ObjectGridAuthorization</code> para autorizar
* el acceso a ObjectGrid y correlaciones. Consulte
<code>ObjectGridAuthorization</code> para obtener más información.
*
* <p>
* Desde XD 6.1, <code>setMapAuthorization</code> está en desuso
* y se recomienda el uso de <code>setObjectGridAuthorization</code>.
No obstante,
* si el plug-in <code>MapAuthorization</code> y el plug-in
<code>ObjectGridAuthorization</code>
* se utilizan, ObjectGrid usará el
<code>MapAuthorization</code> proporcionado para autorizar los
accesos a las correlaciones,
* aunque esté en desuso.
* <p>
* Para evitar una excepción <code>IllegalStateException</code>,
este método
* debe llamarse antes que al método <code>initialize()</code>. Recuerde
también
* que los métodos <code>getSession</code> llaman implícitamente
* al método <code>initialize()</code> si debe llamarlo la
* aplicación.
*
* @param ogAuthorization el plug-in <code>ObjectGridAuthorization</code>
*
* @throws IllegalStateException si se llama a este método después de
* llamar al método <code>initialize()</code>.
*
* @see #initialize()
* @see ObjectGridAuthorization
* @since WAS XD 6.1
*/
void setObjectGridAuthorization(ObjectGridAuthorization ogAuthorization);
El tiempo de ejecución de WebSphere eXtreme Scale llama al método Boolean checkPermission(Subject subject, Permission permission) de la interfaz ObjectGridAuthorization para comprobar si el objeto de asunto pasado tiene el permiso pasado. La implementación de la interfaz ObjectGridAuthorization devuelve true, si el objeto tiene el permiso, y false, si no lo tiene.
Una implementación típica de este plug-in es recuperar los principales del objeto Subject y comprobar si los permisos especificados se han concedido a los principales mediante la consulta de políticas específicas. Estas políticas las definen los usuarios. Por ejemplo, las políticas se pueden definir en una base de datos, en un archivo plano, o un servidor de políticas de Tivoli Access Manager.
Por ejemplo, se puede utilizar el servidor de políticas Tivoli Access Manager para gestionar la política de autorización y utilizar su API para autorizar el acceso. Si desea saber cómo utilizar las API de Tivoli Access Manager Authorization, consulte IBM® Tivoli Access Manager Authorization Java Classes Developer Reference para obtener más detalles.
Esta implementación de ejemplo tiene las siguientes presunciones:
El siguiente fragmento de código muestra cómo implementar el método checkPermission:
/**
* @see com.ibm.websphere.objectgrid.security.plugins.
* MapAuthorization#checkPermission
* (javax.security.auth.Subject, com.ibm.websphere.objectgrid.security.
* MapPermission)
*/
public boolean checkPermission(final Subject subject,
Permission p) {
// Para non-MapPermission, siempre se da la autorización.
if (!(p instanceof MapPermission)){
return true;
}
MapPermission permission = (MapPermission) p;
String[] str = permission.getParsedNames();
StringBuffer pdPermissionStr = new StringBuffer(5);
for (int i=0; i<str.length; i++) {
pdPermissionStr.append(str[i].substring(0,1));
}
PDPermission pdPerm = new PDPermission(permission.getName(),
pdPermissionStr.toString());
Set principals = subject.getPrincipals();
Iterator iter= principals.iterator();
while(iter.hasNext()) {
try {
PDPrincipal principal = (PDPrincipal) iter.next();
if (principal.implies(pdPerm)) {
return true;
}
}
catch (ClassCastException cce) {
// Handle exception
}
}
return false;
}