Lunes, 20-Nov-17, 9:51 AM
Le saludo Visitante | RSS
Menú del sitio
Búsqueda

byronlcl, Access y algunas cosillas...

Seguridad en Access 2

Páginas de este artículo:  1  2  3

9. Seguridad Por Usuarios
9.1 ¿Que Es?
Este tipo de seguridad es la más completa y confiable que nos ofrece Access.
Una base de datos cuenta con varios OBJETOS, como tablas, consultas, reportes, formularios, macros y módulos, nosotros podemos crear USUARIOS y ponerles una contraseña de inicio, luego podemos asignarles permisos a esos usuarios para utilizar todos los objetos mencionados o solo algunos.
En la vida real no siempre nos interesa que un usuario tenga permisos completos sobre un objeto, por citar un ejemplo, a veces necesitamos que un usuario pueda ver un reporte y que pueda imprimirlo, pero no queremos que pueda hacer cambios en el diseño. La seguridad por usuarios nos permite eso, definir permisos específicos para cada objeto.
Los diferentes objetos tienen varios niveles de permisos, que varían según sea el objeto. Veamos una tabla, a esta se le pueden definir los siguientes permisos:
 
-Leer datos (Abrir la tabla y leer los datos)
-Insertar datos (crear nuevos registros)
-Modificar datos
-Eliminar datos (eliminar registros)
-Leer definiciones (ver la tabla en vista de diseño)
-Modificar definiciones (agregar, modificar y eliminar campos, crear índices, etc. en la vista de diseño)
-Leer información de permisos
-Modificar permisos
 
A un usuario se le puede asignar solo un permiso de estos, varios permisos ó todos los permisos. La seguridad por usuarios te permite tener a tus usuarios definidos exactamente como los necesitas, a lo mejor quieres que la secretaria lea los datos de las facturas de compra, pero no necesitas que realice cambios en los datos, ni mucho menos que los elimine.
 
 
9.2 ¿Cómo Funciona?
Para entenderlo debemos comprender como funciona Access, que aunque algunos no sabían, trabaja todo el tiempo con Seguridad por usuarios.
Cada vez que la aplicación de Access inicia, lo primero que hace es consultar un archivo exterior de extensión .mdw, en este archivo se encuentran guardados los nombres de usuarios y contraseñas, a este archivo se le llama GRUPO DE TRABAJO.
Access solamente inicia con un nombre de usuario y contraseña correctos, los cuales valida en el Grupo de trabajo (archivo exterior .mdw), luego, Access se queda conectado al Grupo de trabajo y cada vez que intentamos realizar cualquier operación como abrir un objeto, modificar datos, etc. Access consulta si tenemos los permisos necesarios para realizar tal operación, si no tenemos el permiso lógicamente no nos deja realizar la operación y nos informa.
-Byron, tu dices que Access trabaja todo el tiempo con Seguridad por usuarios, pero a mi nunca me a pedido un nombre de usuario y contraseña...
Te doy detalles del porque:
Cuando abres por primera vez Access, se crea un archivo de Grupo de trabajo llamado "System.mdw", este grupo de trabajo es el que usa Access predeterminadamente, cada base de datos que has creado se conecta a él. Este archivo de grupo de trabajo contiene dos usuarios:
-Admin (Administrador)
-User (Usuario)
Estos usuarios contienen permisos totales sobre toda la base de datos, estos usuarios además están definidos sin contraseña, es decir, con una cadena vacía "".
Cuando Access inicia, predeterminadamente se conecta al grupo de trabajo "System.mdw" y te ingresa predeterminadamente con el usuario "Admin" (Administrador), que como no tiene una contraseña definida, ingresa libremente y no se detiene. La verdad es que el grupo de trabajo Sí preguntó por Usuario y contraseña, pero Access le ingreso el usuario "Admin" y de contraseña una cadena vacía.
Mientras estas usando normalmente tu base de datos tampoco te das cuenta de que se están manejando validaciones de permisos sobre los objetos, esto es porque como dijimos antes, estas ingresado con el usuario Admin, el cual tiene permisos totales y nunca encuentra restricciones.
Hagamos unas pruebas para corroborar lo dicho, vamos a la ventana VBA de Access, abramos la ventana de inmediato (Ctrl+G) y escribamos esto (Copia y pega):
 
Debug.Print "Mi archivo de grupo de trabajo actual es: " & Syscmd(acSysCmdGetWorkgroupFile)
 
Y presiona Enter, te saldrá el nombre del archivo de grupo de trabajo que estas utilizando. Ahora escribe esto:
 
Debug.Print "Mi usuario actual es: " & CurrentUser()
 
Y presiona Enter, se mostrará el nombre del usuario actual con el que estas trabajando, con el que Access te ha ingresado a la base de datos.
 
Ahora que ya tienes una idea general sobre la seguridad por usuarios, entremos en conceptos...
 
 
9.3 ¿Qué Son Los Usuarios y Los Grupos De Usuarios?
Un usuario es una persona individual definida en el grupo de trabajo, al ingresar debe proporcionar su nombre de usuario y una contraseña, esta persona tendrá ciertos permisos para utilizar objetos, estos permisos han sido agregados con anticipación por algún Administrador de seguridad de la base de datos.
La asignación de permisos para un usuario puede ser muy delicada, recordemos que hay que especificarle permisos para cada objeto existente, y para cada objeto existen varios permisos, los cuales varían según sea el tipo de objeto.
Para ahorrar este trabajo se crearon los GRUPOS DE USUARIOS (simplemente los llamaremos GRUPOS), tu puedes crear un nuevo Grupo y asignarle un nombre, luego le puedes asignar permisos de la misma manera que lo harías con un usuario, la ventaja es que cuando ya tienes un grupo bien definido, al grupo le puedes agregar/ingresar usuarios y estos heredan automáticamente todos los permisos del grupo, luego puedes agregar, modificar ó eliminar permisos a dicho grupo y los cambios se reflejan también en los usuarios.
Para citar un ejemplo, puedes crear un grupo llamado "Ventas" que tenga todos los permisos para darle seguimiento a marketing, cotizaciones, pedidos y facturas. Cuando se contrate a una nueva persona para el área de ventas, solo le creas un usuario en el sistema, lo agregas al grupo "Ventas" y ya estará listo para trabajar, sin tener que estar definiendo cada vez los mismos pasos de asignación de permisos.
Luego probablemente te interese crear otro grupo llamado "Vendedores", "Compradores", "Supervisores", etc.
Hay que tomar nota que un usuario puede pertenecer a varios Grupos
Aunque un usuario pertenezca a uno o a varios grupos, también puedes definirle permisos extras.
 
 
9.4 Algo Más...
Ahora que ya sabes lo que son los Grupos, te cuento que el grupo de trabajo "System.mdw" (predeterminado) también tiene dos grupos incluidos:
-Users
-Admins
El usuario User está incluido en el grupo Users
El usuario Admins está incluido en el grupo Admins
El grupo Admins tiene permisos completos sobre toda la base de datos
-íAhora si te he entendido Byron, entonces el usuario Admin es el de mayor jerarquía porque tiene todos los permisos y porque esta incluido en el grupo Admins!
Siento decirte que no, el usuario "Admin" no es el que tiene mayor jerarquía. Revisemos como esta funcionando Access, hagamos estas pruebas:
Crea una nueva base de datos, ponle cualquier nombre (porque nos servirá solo para pruebas)
Esta nueva base de datos no tiene ningún objeto porque no hemos creado nada, pero vamos a las tablas y verás que ya hay tablas creadas, si no puedes verlas ve al menu:
Herramientas/Opciones/Pestaña Ver/Activar casilla "Objetos de Sistema"
El nombre de todas estas tablas comienza por "Msys..."
Ahora, si el usuario "Admin" (con el que estas ingresado) tiene todos los permisos de la base de datos no deberías tener ningún problema en tratar de modificar ó eliminar estas tablas. Haz la prueba, intenta eliminar cualquiera de estas tablas (selecciona la tabla y pulsa la tecla Supr)...
Exacto, nos da un mensaje que dice que no tenemos permiso para eliminar la tabla, pero, ¿Quién tiene este permiso?, hagamos otra comprobación; Dale un clic secundario a cualquiera de estas tablas, en el menú desplegado escojamos la opción "Propiedades", allí veamos quien es el propietario, a mi me sale que es un usuario llamado "Engine".
Veamos otra cosa, entre estas tablas existe una llamada "MSysAccessObjects", repitamos los pasos para ver quién es el propietario, a mi me sale "Admin" ("Administrador") ó sea nosotros en este momento. Si somos los propietarios entonces seguramente podemos hacer lo que queramos con esa tabla, pero no es cierto, si la abrimos para leer los datos no tenemos ningún problema, pero si intentamos eliminarla nos dice que no tenemos permiso (haz la prueba). Esto quiere decir que un usuario mayor nos puso como propietarios de esta tabla, nos dio permiso de lectura y nos quitó el permiso para eliminarla.
Sigamos con las pruebas:
No te preocupes si no entiendes el código a continuación, adelante lo veremos más a detalle. Ahora, en un Módulo nuevo escribe este procedimiento (copia y pega):
 
Sub ListarUsuarios()
Dim usr As DAO.User
   For Each usr In DBEngine.Workspaces(0).Users
      Debug.Print usr.Name
   Next usr
End Sub
 
Ve a la Ventana Inmendiato (si no esta abierta presiona Ctrl+G), escribe lo siguiente:
 
ListarUsuarios
 
Y presiona Enter, se escribirán los usuarios que tiene la base de datos, a mí me sale:
 
- Admin
- Creator
- Engine
 
El usuario Admin somos nosotros, los otros dos usuarios, Creator y Engine le pertenecen a Access y no podemos hacer nada con ellos, ni modificarlos ni eliminarlos.
Hay que mencionar también que los usuarios Admin y User no pueden ser eliminados.
Si quieres ver los grupos predeterminados, escribe este nuevo procedimiento:
 
Sub ListarGrupos()
Dim grp As DAO.Group
   For Each grp In DBEngine.Workspaces(0).Groups
      Debug.Print grp.Name
   Next grp
End Sub
 
En la ventana de inmediato escribimos:
 
ListarGrupos
 
Y hacemos Enter, se nos lista los grupos de usuarios existentes, a mí me sale:
 
Admins
Users
 
Estos dos grupos son predeterminados y tampoco se pueden eliminar. Del grupo Admins ya hemos hablado.
Cuando creas un nuevo usuario manualmente, este automáticamente queda ingresado en el grupo de Users (Usuarios), si quieres que este usuario esté también en el grupo de Administradores tendrás que ingresarlo en un paso siguiente
 
 
9.5 Activar La Seguridad Por Usuarios A Una Base De Datos
Como mencionamos antes, Access trabaja siempre con la seguridad por usuarios, que se encuentra en un Grupo de trabajo que es un archivo externo llamado "System.mdw", cada base de datos nueva que creemos se conecta a este archivo.
Si nosotros necesitamos agregarle a una base de datos la seguridad por usuarios, en realidad lo que hacemos es crear un nuevo Grupo de trabajo (un archivo .mdw), luego necesitamos decirle a Access que para abrir esta BD lo haga a través de este nuevo grupo de trabajo.
Para realizar este proceso, lo más fácil es hacerlo por el asistente, que se encuentra en el menú:
Herramientas/Seguridad/Asistente para seguridad por usuarios...
Allí seguimos todos los pasos del asistente leyendo detenidamente cada paso hasta finalizar. Cuando se termina este proceso, Access nos da un informe de cómo quedaron las cosas y nos permite guardar la información en otro lugar para que pueda servirnos más adelante. Todo este proceso lo que hace es:
-Crear un nuevo grupo de trabajo, un archivo .mdw
-Obliga a crear un nuevo usuario en el grupo de Administradores
-Al usuario Admin se le quitan todos los permisos
-Al usuario Admin se le coloca una contraseña
Con esto se logra que al iniciar Access nos lance la pantalla de ingreso donde pide usuario y contraseña, porque como vimos anteriormente, Access inicialmente intenta ingresar con un el usuario Admin y con una contraseña vacía, la cual encuentra que no coincide (porque ahora hay una contraseña) y nos lanza la pantalla de ingreso
-El usuario "Admin" es sacado del grupo de "Admins"
Esto es porque el grupo Admins siempre mantiene los permisos completos
-A los objetos existentes se les cambia de propietario, se les pone el nuevo usuario administrador ingresado en el proceso
 
 
9.6 Programando
A este punto debes tener entendido todo lo dicho anteriormente sobre como funciona la seguridad por usuarios, si tienes dudas por favor vuelve a leer desde el principio y cuando todo esté claro continuas
Bueno, aquí viene lo bonito ya que empezaremos a ver todo lo dicho anteriormente pero con código.
 
IMPORTANTE
No trabajes los usuarios y grupos de usuarios sobre el grupo de trabajo predeterminado de Access "System.mdw", porque si haces cambios, este se reflejará sobre todas las bases de datos que tienes y las nuevas que crees.
Crea una base de datos nueva, agrégale un nuevo grupo de trabajo como se especifica en el punto anterior "Agregar La Seguridad Por Usuarios A Una Base De Datos", y así solo esa base de datos estará protegida.
En este artículo intento dar las explicaciones de cómo se realizan las operaciones manualmente y con código. Si eres nuevo en este tema (seguridad por usuarios), te aconsejo que vallas aprendiendo de cómo se realizan las cosas solo manualmente, porque el código puede confundirte. Solo cuando ya tengas experiencia manejando las cosas manualmente empieza el aprendizaje del código
Programando...
Microsoft Access trabaja la totalidad de operaciones de seguridad a través de dos conjuntos:
- Grupos de trabajo, Grupos, Usuarios y Contraseñas
- Objetos de la base de datos y permisos
Estos conjuntos se operan de manera diferente, y los detallamos a continuación
 
 
9.7 Grupos de trabajo, Grupos, Usuarios y Contraseñas
Para administrar manualmente los Grupos, Usuarios y contraseñas puedes ir al menú:
Herramientas/Seguridad/Cuentas de usuario y de grupo...
Pero nuestra intención es automatizarlo, así que este conjunto lo podemos trabajar con el objeto Application.DBEngine.
 
Veamos como podemos establecer referencias a los objetos, para hacer referencia al grupo de trabajo actual tenemos:
 
Dim ws As DAO.Workspace
   Set ws = DBEngine.Workspaces(0)
 
Para hacer referencia a un usuario:
 
Dim ws As DAO.Workspace
Dim usr As DAO.User
   Set ws = DBEngine.Workspaces(0)
   Set usr = ws.Users("NombreUsuario")
 
Para hacer referencia a un grupo:
 
Dim ws As DAO.Workspace
Dim grp As DAO.Group
   Set ws = DBEngine.Workspaces(0)
   Set grp = ws.Groups("NombreGrupo")
 
Para hacer referencia a los usuarios que pertenecen a un grupo:
 
Dim ws As DAO.Workspace
Dim usrs As DAO.Users
   Set ws = DBEngine.Workspaces(0)
   Set usrs = ws.Groups("NombreGrupo").Users
 
Para hacer referencia a los grupos a los cuales pertenece un usuario:
 
Dim ws As DAO.Workspace
Dim grps As DAO.Groups
   Set ws = DBEngine.Workspaces(0)
   Set grps = ws.Users("NombreUsuario").Groups
Conociendo esta lógica, ahora podemos entender los procedimientos siguientes:
 
Listar los usuarios del sistema:
 
Sub ListarUsuarios()
'Byron Contreras - byronlcl@gmail.com - 2,009
'.............................................
Dim usr As DAO.User
   For Each usr In DBEngine.Workspaces(0).Users
      Debug.Print usr.Name
   Next usr
End Sub
 
Listar los grupos del sistema:
 
Sub ListarGrupos()
'Byron Contreras - byronlcl@gmail.com - 2,009
'.............................................
Dim grp As DAO.Group
   For Each grp In DBEngine.Workspaces(0).Groups
      Debug.Print grp.Name
   Next grp
End Sub
 
Listar los usuarios que pertenecen a un grupo:
 
Sub ListarUsuariosEnGrupo(ByVal strGrupo As String)
'Byron Contreras - byronlcl@gmail.com - 2,009
'.............................................
Dim usr As DAO.User
   For Each usr In DBEngine.Workspaces(0).Groups(strGrupo).Users
      Debug.Print usr.Name
   Next usr
End Sub
 
Lista de grupos a los cuales pertenece un usuario:
 
Sub ListarGruposDeUsuario(ByVal strUsuario As String)
'Byron Contreras - byronlcl@gmail.com - 2,009
'.............................................
Dim grp As DAO.Group
   For Each grp In DBEngine.Workspaces(0).Users(strUsuario).Groups
      Debug.Print grp.Name
   Next grp
End Sub
 
Crear un usuario:
 
Sub CrearUsuario(ByVal strNombreUsuario As String, _
                 ByVal strIdUsuario As String, _
                 Optional ByVal strContraseña As String = "")
'Byron Contreras - byronlcl@gmail.com - 2,009
'.............................................
Dim usr As DAO.User
   With DBEngine.Workspaces(0)
      Set usr = .CreateUser(strNombreUsuario, strIdUsuario, strContraseña)
      .Users.Append usr
      .Users.Refresh
      'agregarlo al grupo Users
      With .Groups("Users")
         Set usr = .CreateUser(strNombreUsuario)
         .Users.Append usr
         .Users.Refresh
      End With
   End With
Set usr = Nothing
End Sub
 
Crear un grupo:
 
Sub CrearGrupo(ByVal strNombreGrupo As String, ByVal strIdGrupo As String)
'Byron Contreras - byronlcl@gmail.com - 2,009
'.............................................
Dim grp As DAO.Group
   With DBEngine.Workspaces(0)
      Set grp = .CreateGroup(strNombreGrupo, strIdGrupo)
      .Groups.Append grp
      .Groups.Refresh
   End With
   Set grp = Nothing
End Sub
 
Agregar un usuario a un grupo:
 
Sub AgregarUsuario_a_Grupo(ByVal strUsuario As String, ByVal strGrupo As String)
'Byron Contreras - byronlcl@gmail.com - 2,009
'.............................................
Dim usr As DAO.User
   With DBEngine.Workspaces(0).Groups(strGrupo)
      Set usr = .CreateUser(strUsuario)
      .Users.Append usr
      .Users.Refresh
   End With
End Sub
 
Eliminar un usuario definitivamente:
 
Sub EliminarUsuario(ByVal strUsuario As String)
'Byron Contreras - byronlcl@gmail.com - 2,009
'.............................................
   DBEngine.Workspaces(0).Users.Delete strUsuario
End Sub
 
Eliminar un grupo definitivamente:
 
Sub EliminarGrupo(ByVal strGrupo As String)
'Byron Contreras - byronlcl@gmail.com - 2,009
'.............................................
   DBEngine.Workspaces(0).Groups.Delete strGrupo
End Sub
 
Eliminar a un usuario de un grupo:
 
Sub EliminarUsuario_de_Grupo(ByVal strUsuario As String, ByVal strGrupo As String)
'Byron Contreras - byronlcl@gmail.com - 2,009
'.............................................
   DBEngine.Workspaces(0).Groups(strGrupo).Users.Delete strUsuario
End Sub
 
Cambiar la contraseña para un usuario:
 
Sub CambiarContraseña(ByVal strUsuario As String, _
                      ByVal strContraseñaAnterior As String, _
                      ByVal strContraseñaNueva As String)
'Byron Contreras - byronlcl@gmail.com - 2,009
'.............................................
   With DBEngine.Workspaces(0)
      .Users(strUsuario).NewPassword strContraseñaAnterior, strContraseñaNueva
   End With
End Sub
 
Determinar si existe un usuario:
 
Function ExisteUsuario(ByVal strUsuario As String) As Boolean
'Byron Contreras - byronlcl@gmail.com - 2,009
'.............................................
Dim usr As DAO.User
   On Error Resume Next
   Set usr = DBEngine.Workspaces(0).Users(strUsuario)
   If Err.Number = 0 Then
      ExisteUsuario = True
   Else
      Err.Clear
   End If
   Set usr = Nothing
End Function
 
Determinar si existe un grupo:
 
Function ExisteGrupo(ByVal strGrupo As String) As Boolean
'Byron Contreras - byronlcl@gmail.com - 2,009
'.............................................
Dim grp As DAO.Group
   On Error Resume Next
   Set grp = DBEngine.Workspaces(0).Groups(strGrupo)
   If Err.Number = 0 Then
      ExisteGrupo = True
   Else
      Err.Clear
   End If
   Set grp = Nothing
End Function
 
Determinar si un usuario pertenece a un grupo:
 
Function ExisteUsuarioEnGrupo(ByVal strGrupo As String, ByVal strUsuario As String) As Boolean
'Byron Contreras - byronlcl@gmail.com - 2,009
'.............................................
Dim usr As DAO.User
   On Error Resume Next
   Set usr = DBEngine.Workspaces(0).Groups(strGrupo).Users(strUsuario)
   If Err.Number = 0 Then
      ExisteUsuarioEnGrupo = True
   Else
      Err.Clear
   End If
   Set usr = Nothing
End Function
 
 
9.8 Objetos De La Base De Datos Y Permisos
Para administrar manualmente los permisos de los objetos puedes ir al menú:
Herramientas/Seguridad/Permisos de usuario y de grupo...
Para automatizar los permisos de la base de datos podemos trabajar a través de dos métodos; ADOX y DAO.
ADOX tiene la desventaja que falla a la hora de trabajar con reportes, formularios, macros y módulos, ADOX esta bien para trabajar otro tipo de bases de datos, las cuales no incluyen estos objetos. Por esta razón dejaremos ADOX por un lado y solo nos enfocaremos en DAO.
DAO nos ofrece la siguiente jerarquía de objetos:
 
Container > Document > Permission
 
Que más o menos quieren decir:
 
Container: Colección de objetos por tipo (Tablas, consultas, reportes, macros ó módulos)
Ducument: Objeto específico (tabla, consulta, reporte, formulario, macro ó módulo)
Permission: Permisos para el objeto específico
 
Podemos acceder a estos elementos bajo el objeto "base de datos", que es fácil de describir porque trabajamos con el a menudo:
 
Dim db As DAO.Database
   Set db = Application.CurrentDb
 
Veamos los objetos más a detalle:
 
Container (Colección de objetos de un tipo específico)
Se refiere a la colección completa de un tipo específico. Entre los Containers tenemos:
- Tables (Tablas y Consultas)
- Forms (Formularios)
- Reports (Reportes)
- DataAccessPages (Páginas de datos)
- Scripts (Macros)
- Modules (Módulos)
- Databases (Bases de datos del grupo de trabajo)
También existen otros Containers que no usamos mucho:
- Relationships (Relaciones)
- SysRel (Relaciones del sistema)
 
Document (Objeto específico)
Se refiere a un objeto como una tabla, consulta, reporte, formulario, etc. Si tomamos por ejemplo la tabla "Clientes", esta es un Document que se encuentra dentro del Container "Tables"
 
Permission (Permiso)
Los permisos son un valor de tipo Entero Largo (Long), en el cual podemos leer, asignar, modificar ó eliminar valores de permisos.
Veamos algo de código sobre lo que hemos explicado hasta ahora:
Imaginemos que tenemos al usuario "Byron Contreras" y queremos obtener los permisos que tiene sobre la tabla "Clientes"
 
Dim db As DAO.Database
Dim cont As DAO.Container
Dim doc As DAO.Document
Dim lngPermisos as Long
   'Base de datos
   Set db = CurrentDB
   'Container (colección a la que pertenece el objeto que nos interesa)
   Set cont = db.Containers("Tables")
   'Document (Objeto específico)
   Set doc = cont.Documents("Clientes")
   'Usuario sobre el que se hará la consulta
   doc.UserName = "Byron Contreras"
   'Permisos
   lngPermisos = doc.Permissions
 
En este momento, en la variable "lngPermisos" se encuentra un valor que representa a todos los permisos que se tienen sobre el objeto.
 
 
9.9 Permisos Específicos
Los permisos que se pueden leer, asignar ó eliminar varían dependiendo del objeto. Entre las constantes de permisos, para los diferentes objetos tenemos:
 
Constante: Valor: Container (Aplica a): Permiso para:
dbSecDBCreate 1 Base de datos Crear nuevas bases de datos
dbSecDBAdmin 8 Base de datos Replicar o cambiar contraseña
dbSecDBOpen 2 Base de datos Abrir
dbSecDBExclusive 4 Base de datos Abrir en modo exclusivo
dbSecReadDef 4 Tablas y Consultas Leer definiciones
dbSecWriteDef 65548 Tablas y Consultas Editar/modificar/actualizar y eliminar definiciones
dbSecRetrieveData 20 Tablas y Consultas Leer datos
dbSecInsertData 32 Tablas y Consultas Insertar datos
dbSecReplaceData 64 Tablas y Consultas Editar/modificar/actualizar datos
dbSecDeleteData 128 Tablas y Consultas Eliminar datos
acSecFrmRptExecute 256 Formularios y Reportes Abrir
acSecFrmRptReadDef 4 Formularios y Reportes Leer el diseño
acSecFrmRptWriteDef 65548 Formularios y Reportes Modificar el diseño
acSecMacExecute 8 Macros Ejecutar
acSecMacReadDef 10 Macros Leer el diseño
acSecMacWriteDef 65542 Macros Modificar
acSecModReadDef 2 Módulos Leer
acSecModWriteDef 65542 Módulos Editar
dbSecNoAccess 0 Todos Ningún permiso
dbSecFullAccess 1048575 Todos Permisos completos(Administrar)
dbSecCreate 1 Todos Crear nuevos objetos
dbSecDelete 65536 Todos Eliminar
dbSecReadSec 131072 Todos Leer información de seguridad (permisos)
dbSecWriteSec 262144 Todos Editar/modificar/actualizar información de seguridad (permisos)
dbSecWriteOwner 524288 Todos Cambiar el propietario del objeto
 
En realidad los permisos son un valor tipo BitMask, en el cual tenemos que realizar comparaciones con los operadores AND, OR, AND NOT para obtener los resultados que deseamos, por ejemplo:
En el código anterior se puede observar como obtener el valor de permisos que contiene un Document, este valor lo encontramos en:
 
doc.Permissions
 
Para revisar si hay un permiso específico:
 
If (doc.Permissions AND dbSecRetrieveData) Then
   Msgbox "Si hay permiso para leer datos"
End if
 
Para asignar un permiso:
 
doc.Permissions = doc.Permissions OR dbSecInsertData
Para eliminar un permiso:
 
con.Permissions = con.Permissions AND NOT dbSecDeleteData
 
Veamos este ejemplo completo:
Imaginemos que tenemos al usuario "Byron Contreras", y queremos saber si tiene el permiso de "Insertar datos" en la tabla "Clientes", si no tiene el permiso se lo asignamos. Al final también le quitaremos el permiso de eliminar datos de la misma tabla
 
Dim db As DAO.Database
Dim cont As DAO.Container
Dim doc As DAO.Document
   'Base de datos
   Set db = CurrentDB
   'Container (colección a la que pertenece el objeto que nos interesa)
   Set cont = db.Containers("Tables")
   'Document (Objeto específico)
   Set doc = cont.Documents("Clientes")
   'Usuario sobre el que se hará la consulta
   doc.UserName = "Byron Contreras"
   '¿Tiene Permiso?
   'verificamos el valor BitMask de permisos con el valor específico del permiso
   If (doc.Permissions AND dbSecInsertData) then
      Msgbox "Si hay permiso para leer datos"
   Else
      'aquí entramos porque no hay permiso, entonces se lo asignamos
      doc.permissions = doc.permissions OR dbSecInsertData
   End If
   'Quitarle el permiso para eliminar datos
   doc.permissions = doc.permissions AND NOT dbSecDeleteData
   set doc = Nothing
   set cont = Nothing
   set db = Nothing
 
 
9.10 Casos Especiales De Permisos
Objetos Nuevos:
Existe un tipo de permiso para poder crear objetos nuevos, aquí no tenemos un nombre de Document. Para verificar este permiso lo hacemos directamente sobre el Container.
Revisemos si el usuario "Byron Contreras" tiene permiso de crear nuevas tablas:
 
Dim db As DAO.Database
Dim cont As DAO.Container
   'Base de datos
   Set db = CurrentDB
   'Contenedor (colección a la que pertenece el objeto que nos interesa)
   Set cont = db.Containers("Tables")
   'Usuario sobre el que se hará la consulta
   cont.UserName = "Byron Contreras"
   '¿Tiene Permiso?
   'verificamos el valor BitMask de permisos con el valor específico del permiso
   If cont.Permissions AND dbSecCreate then
      Msgbox "Si existen permisos para crear tablas nuevas"
   End If
   set cont = Nothing
   set db = Nothing
 
Permisos Sobre La Base De Datos:
Cuando revisamos permisos para la Base de datos, el nombre del Document siempre se llama "Msysdb".
Revisemos si el usuario "Byron Contreras" tiene permiso de abrir la base de datos:
 
Dim db As DAO.Database
Dim cont As DAO.Container
Dim doc As DAO.Document
   'Base de datos
   Set db = CurrentDB
   'Contenedor (colección a la que pertenece el objeto que nos interesa)
   Set cont = db.Containers("Databases")
   'Documento (Objeto específico)
   Set doc = cont.Documents("Msysdb")
   'Usuario sobre el que se hará la consulta
   doc.UserName = "Byron Contreras"
   '¿Tiene Permiso?
   'verificamos el valor BitMask de permisos con el valor específico del permiso
   If doc.Permissions AND dbSecDBOpen then
      MsgBox "Si tienes permiso para abrir la base de datos"
   End If
   set doc = Nothing
   set cont = Nothing
   set db = Nothing
 
 
9.11 Verificar Si Un Usuario Tiene Un Permiso
(Para verificar un permiso específico favor de ir atrás al inciso 9.9 Permisos Específicos)
Nosotros podemos revisar si un usuario tiene algún permiso específico sobre un objeto y obtener que NO existen permisos, pero podría ser que el usuario SI tenga el permiso porque este se podría estar heredando. Un usuario puede tener permiso sobre un objeto por varias razones:
- El usuario tiene permisos dados sobre el objeto
- El usuario pertenece a un grupo, este grupo tiene permisos sobre el objeto y el usuario está heredando los permisos del grupo
- El usuario es el propietario del objeto (creador)
Para conocer si un usuario tiene un permiso, no importando de donde venga podemos consultar la propiedad "AllPermissions" del Document:
 
Dim db As DAO.Database
Dim cont As DAO.Container
Dim doc As DAO.Document
   'Base de datos
   Set db = CurrentDb
   'Contenedor (colección a la que pertenece el objeto que nos interesa)
   Set cont = db.Containers("Databases")
   'Documento (Objeto específico)
   Set doc = cont.Documents("Msysdb")
   'Usuario sobre el que se hará la consulta
   doc.UserName = "Byron Contreras"
 
   '¿Tiene Permiso?
   'verificamos el valor BitMask de permisos con el valor específico del permiso
   If doc.AllPermissions And dbSecDBOpen Then
      MsgBox "Si tienes permiso para abrir la base de datos"
   End If
 
   Set doc = Nothing
   Set cont = Nothing
   Set db = Nothing
 
Aquí sabemos si realmente existe el permisos para el usuario, auque no sabemos si viene por permiso directo al usuario, si viene de algún grupo ó por ser el propietario
 
 
9.12 Propietario De Los Objetos (Owner)
Todos los objetos tienen un propietario, que es el nombre del usuario que los ha creado. El propietario del objeto predeterminadamente tiene todos los permisos sobre el objeto. También es posible cambiar de propietario a los objetos.
Veamos un ejemplo de como conocer quién es el propietario (Owner) de un objeto:
Queremos conocer al dueño de la tabla "Clientes":
 
Dim db As DAO.Database
Dim cont As DAO.Container
Dim doc As DAO.Document
Dim strDueño As String
   Set db = CurrentDb
   Set cont = db.Containers("Tables")
   Set doc = cont.Documents("Clientes")
   strDueño = doc.Owner
   MsgBox "El dueño de la tabla Clientes es: " & strDueño
Set doc = Nothing
Set cont = Nothing
Set db = Nothing