Creación de su propio gestor de acceso de seguridad

El gestor de acceso de seguridad es usado por OpenKM 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 dentro del 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.PrincipalAdapterException;
import net.xeoh.plugins.base.Plugin;

/**
 * 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 PrincipalAdapterException, 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 Security access manager, 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 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
:::

Method	Type	Description
checkPermission(NodeBase node, int permissions)	void	Descripción
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 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 cuadro de clasificación (file plan) está habilitado.

Ejemplo de implementación del 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.PrincipalAdapterException;
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 PrincipalAdapterException, 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;
  }
}