Crear su propio gestor de acceso de seguridad

OpenKM usa el gestor de acceso de seguridad para comprobar el nivel de acceso de seguridad de un usuario a los nodos.

Condiciones:

• La nueva clase Principal Adapter debe implementar la interfaz “DbAccessManager”.
• La nueva clase Principal Adapter debe declararse bajo el paquete “com.openkm.plugin.access”.
• La nueva clase Principal Adapter debe estar anotada con “@PluginImplementation”.
• La nueva clase Principal Adapter debe extender “BasePlugin”.

Interfaz del gestor de acceso de seguridad:

package com.openkm.plugin.access;

import com.openkm.core.AccessDeniedException;
import com.openkm.core.DatabaseException;
import com.openkm.core.PathNotFoundException;
import com.openkm.db.bean.NodeBase;
import com.openkm.principal.AuthException;
import net.xeoh.plugins.base.Plugin;

import java.util.Set;

/**
 * Check user permissions on documents and folders.
 *
 * @author pavila
 */
public interface DbAccessManager extends Plugin {

  void checkPermission(NodeBase node, int permissions) throws AccessDeniedException, PathNotFoundException, DatabaseException;

  boolean isGranted(NodeBase node, int permissions) throws DatabaseException, PathNotFoundException;

  boolean isGranted(NodeBase node, String user, int permissions) throws AuthException, DatabaseException, PathNotFoundException;

  boolean isGranted(NodeBase node, String user, Set<String> roles, int permissions) throws AuthException, DatabaseException, PathNotFoundException;

  boolean isGranted(NodeBase node, long nodeClass, int permissions) throws DatabaseException;
}

La nueva clase debe cargarse en el paquete com.openkm.plugin.access porque el sistema de plugins de la aplicación intentará cargarla desde ahí.

Precaución

No omita la etiqueta @PluginImplementation; de lo contrario, el sistema de plugins de la aplicación no podrá recuperar la nueva clase.

Nota

Más información disponible en Register a new plugin.

Para habilitar el nuevo gestor de acceso de seguridad, vaya a Administration > Configuration parameters > busque el parámetro llamado security.access.manager y establezca el valor a com.openkm.plugin.access.OwnSecurityManager

Para que este cambio surta efecto, es necesario reiniciar la aplicación.

Descripción de los métodos

Nota

En la siguiente tabla, los valores de permiso son (más información en la clase Permission.java):

0	NONE
1	READ
2	WRITE
4	DELETE
8	SECURITY
16	MOVE
1024	DOWNLOAD
2048	START WORKFLOW
4096	COMPACT HISTORY
8192	METADATA
:::

Método	Tipo	Descripción
checkPermission(NodeBase node, int permissions)	void	Comprueba si el usuario actual tiene el permiso especificado sobre el nodo dado. Lanza AccessDeniedException si el permiso no está concedido.
isGranted(NodeBase node, int permissions)	Boolean	Devuelve true cuando el usuario de la sesión tiene el permiso.
isGranted(NodeBase node, String user, int permissions)	Boolean	Devuelve true cuando el usuario especificado tiene el permiso.
isGranted(NodeBase node, String user, Set roles, int permissions)	Boolean	Devuelve true cuando el usuario especificado con los roles dados tiene el permiso.
isGranted(NodeBase node, long nodeClass, int permissions)	Boolean	Devuelve true cuando el usuario de la sesión tiene el permiso. Este método solo tiene sentido cuando el plan de expediente (file plan) está habilitado.

Ejemplo de implementación de un gestor de acceso de seguridad

package com.openkm.plugin.access;

import com.openkm.core.AccessDeniedException;
import com.openkm.core.Config;
import com.openkm.core.DatabaseException;
import com.openkm.core.PathNotFoundException;
import com.openkm.db.bean.NodeBase;
import com.openkm.db.bean.NodeClass;
import com.openkm.db.service.NodeBaseSrv;
import com.openkm.db.service.NodeClassSrv;
import com.openkm.module.common.CommonAuthModule;
import com.openkm.plugin.BasePlugin;
import com.openkm.plugin.fileplan.security.FilePlanAccessManager;
import com.openkm.principal.AuthException;
import com.openkm.principal.PrincipalUtils;
import com.openkm.util.StackTraceUtils;
import net.xeoh.plugins.base.annotations.PluginImplementation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Check user permissions on documents and folders.
 *
 * @see com.openkm.plugin.access.DbRecursiveAccessManager
 */
@PluginImplementation
public class DbSimpleAccessManager extends BasePlugin implements DbAccessManager {
  private static final Logger log = LoggerFactory.getLogger(DbSimpleAccessManager.class);

  @Autowired
  private CommonAuthModule commonAuthModule;

  @Autowired
  private NodeClassSrv nodeClassSrv;

  @Autowired
  private NodeBaseSrv nodeBaseSrv;

  /**
   * Check for permissions.
   */
  public void checkPermission(NodeBase node, int permissions) throws AccessDeniedException, PathNotFoundException, DatabaseException {
    if (!isGranted(node, permissions)) {
      String nodePath = nodeBaseSrv.getPathFromUuid(node.getUuid());
      throw new AccessDeniedException(node.getUuid() + " : " + nodePath);
    }
  }

  /**
   * Check for permissions.
   */
  @Override
  public boolean isGranted(NodeBase node, int permissions) throws DatabaseException {
    String userId = PrincipalUtils.getUser();
    Set<String> roles = PrincipalUtils.getRoles();
    return isGranted(node, userId, roles, permissions);
  }

  /**
   * Check for permissions.
   */
  @Override
  public boolean isGranted(NodeBase node, String user, int permissions) throws AuthException, DatabaseException {
    List<String> roles = commonAuthModule.getRolesByUser(user);
    return isGranted(node, user, new HashSet<>(roles), permissions);
  }

  @Override
  public boolean isGranted(NodeBase node, long nodeClass, int permissions) throws DatabaseException {
    NodeClass nc = nodeClassSrv.findByPk(nodeClass);
    FilePlanAccessManager accessManager = nodeClassSrv.findAccessManagerByClassName(nc.getAccessManagerClassName());
    return accessManager.isGranted(node, nodeClass, PrincipalUtils.getUser(), PrincipalUtils.getRoles(), permissions);
  }

  /**
   * Check for permissions.
   */
  private boolean isGranted(NodeBase node, String user, Set<String> roles, int permissions) {
    log.debug("isGranted({}, {})", node.getUuid(), permissions);
    boolean access;

    if (user != null) {
      if (Config.SYSTEM_USER.equals(user) || Config.ADMIN_USER.equals(user)) {
        // An okmAdmin user has total access
        access = true;
      } else {
        if (roles.contains(Config.DEFAULT_ADMIN_ROLE)) {
          // An user with AdminRole has total access
          access = true;
        } else {
          access = checkProperties(node.getUserPermissions(), node.getRolePermissions(), user, roles, permissions);
        }
      }
    } else {
      access = true;

      log.info("*****************************************************");
      StackTraceUtils.logTrace(log);
      log.info("*****************************************************");
    }

    log.debug("isGranted: {}", access);
    return access;
  }

  /**
   * Check access properties
   */
  private boolean checkProperties(Map<String, Integer> usersPerms, Map<String, Integer> rolesPerms, String user,
      Set<String> roles, int perms) {
    log.debug("checkProperties({}, {}, {}, {})", usersPerms, rolesPerms, roles, perms);
    boolean access = false;

    // Fist try with user permissions
    Integer userPerms = usersPerms.get(user);

    if (userPerms != null && (perms & userPerms) != 0) {
      log.debug("checkProperties: {}", true);
      return true;
    }

    // If there is no user specific access, try with roles permissions
    for (String role : roles) {
      Integer rolePerms = rolesPerms.get(role);

      if (rolePerms != null && (perms & rolePerms) != 0) {
        log.debug("checkProperties: {}", true);
        return true;
      }
    }

    log.debug("checkProperties: {}", access);
    return access;
  }
}