Ir al contenido principal

Management API

The Management API covers all policy and grouping (role) operations: get, add, remove, update, filter. Below, e is an Enforcer instance.

Filtered API​

Filtered methods take (fieldIndex int, fieldValues ...string): matching starts at fieldIndex, and fieldValues are the required values at consecutive positions. Use "" in fieldValues as a wildcard for that position.

Ejemplo:

p, alice, book, read
p, bob, book, read
p, bob, book, write
p, alice, pen, get
p, bob, pen ,get
e.GetFilteredPolicy(1, "book") // returns: [["alice", "book", "read"], ["bob", "book", "read"], ["bob", "book", "write"]]

e.GetFilteredPolicy(1, "book", "read") // returns: [["alice", "book", "read"], ["bob", "book", "read"]]

e.GetFilteredPolicy(0, "alice", "", "read") // returns: [[alice book read]]

e.GetFilteredPolicy(0, "alice") // returns: [["alice", "book", "read"], ["alice", "pen", "get"]]

API Reference​

e, err := NewEnforcer("examples/rbac_model.conf", "examples/rbac_policy.csv")

Enforce()​

Enforce decide si un "sujeto" puede acceder a un "objeto" con la operación "acción", los parámetros de entrada suelen ser: (sub, obj, act).

Por ejemplo:

ok, err := e.Enforce(request)

EnforceWithMatcher()​

EnforceWithMatcher utiliza un comparador personalizado para decidir si un "sujeto" puede acceder a un "objeto" con la operación "acción", los parámetros de entrada suelen ser: (matcher, sub, obj, act), se usa el comparador del modelo por defecto cuando matcher es "".

For example:

ok, err := e.EnforceWithMatcher(matcher, request)

EnforceEx()​

EnforceEx explica la aplicación informando sobre las reglas coincidentes.

For example:

ok, reason, err := e.EnforceEx(request)

EnforceExWithMatcher()​

EnforceExWithMatcher utiliza un comparador personalizado y explica la aplicación informando sobre las reglas coincidentes.

Por ejemplo:

ok, reason, err := e.EnforceExWithMatcher(matcher, request)

BatchEnforce()​

BatchEnforce aplica cada solicitud y devuelve el resultado en un array de booleanos

For example:

boolArray, err := e.BatchEnforce(requests)

GetAllSubjects()​

GetAllSubjects obtiene la lista de sujetos que aparecen en la política actual.

For example:

allSubjects := e.GetAllSubjects()

GetAllNamedSubjects()​

GetAllNamedSubjects obtiene la lista de sujetos que aparecen en la política nombrada actual.

For example:

allNamedSubjects := e.GetAllNamedSubjects("p")

GetAllObjects()​

GetAllObjects obtiene la lista de objetos que aparecen en la política actual.

For example:

allObjects := e.GetAllObjects()

GetAllNamedObjects()​

GetAllNamedObjects obtiene la lista de objetos que aparecen en la política nombrada actual.

For example:

allNamedObjects := e.GetAllNamedObjects("p")

GetAllActions()​

GetAllActions obtiene la lista de acciones que aparecen en la política actual.

For example:

allActions := e.GetAllActions()

GetAllNamedActions()​

GetAllNamedActions obtiene la lista de acciones que aparecen en la política nombrada actual.

For example:

allNamedActions := e.GetAllNamedActions("p")

GetAllRoles()​

GetAllRoles obtiene la lista de roles que aparecen en la política actual.

For example:

allRoles = e.GetAllRoles()

GetAllNamedRoles()​

GetAllNamedRoles obtiene la lista de roles que aparecen en la política nombrada actual.

For example:

allNamedRoles := e.GetAllNamedRoles("g")

GetPolicy()​

GetPolicy obtiene todas las reglas de autorización en la política.

For example:

policy = e.GetPolicy()

GetFilteredPolicy()​

GetFilteredPolicy obtiene todas las reglas de autorización en la política, se pueden especificar filtros de campo.

For example:

filteredPolicy := e.GetFilteredPolicy(0, "alice")

GetNamedPolicy()​

GetNamedPolicy obtiene todas las reglas de autorización en la política nombrada.

For example:

namedPolicy := e.GetNamedPolicy("p")

GetFilteredNamedPolicy()​

GetFilteredNamedPolicy obtiene todas las reglas de autorización en la política nombrada, se pueden especificar filtros de campo.

For example:

filteredNamedPolicy = e.GetFilteredNamedPolicy("p", 0, "bob")

GetGroupingPolicy()​

GetGroupingPolicy obtiene todas las reglas de herencia de roles en la política.

For example:

groupingPolicy := e.GetGroupingPolicy()

GetFilteredGroupingPolicy()​

GetFilteredGroupingPolicy obtiene todas las reglas de herencia de roles en la política, se pueden especificar filtros de campo.

For example:

filteredGroupingPolicy := e.GetFilteredGroupingPolicy(0, "alice")

GetNamedGroupingPolicy()​

GetNamedGroupingPolicy obtiene todas las reglas de herencia de roles en la política nombrada.

For example:

namedGroupingPolicy := e.GetNamedGroupingPolicy("g")

GetFilteredNamedGroupingPolicy()​

GetFilteredNamedGroupingPolicy obtiene todas las reglas de herencia de roles en la política nombrada.

For example:

namedGroupingPolicy := e.GetFilteredNamedGroupingPolicy("g", 0, "alice")

HasPolicy()​

HasPolicy determina si existe una regla de autorización.

For example:

hasPolicy := e.HasPolicy("data2_admin", "data2", "read")

HasNamedPolicy()​

HasNamedPolicy determina si existe una regla de autorización con nombre.

For example:

hasNamedPolicy := e.HasNamedPolicy("p", "data2_admin", "data2", "read")

AddPolicy()​

AddPolicy añade una regla de autorización a la política actual. Si la regla ya existe, la función devuelve false y la regla no se añadirá. De lo contrario, la función devuelve true al añadir la nueva regla.

For example:

added := e.AddPolicy('eve', 'data3', 'read')

AddPolicies()​

AddPolicies añade reglas de autorización a la política actual. La operación es de naturaleza atómica. Por lo tanto, si las reglas de autorización consisten en reglas que no son consistentes con la política actual, la función devuelve false y ninguna regla de la política se añade a la política actual. Si todas las reglas de autorización son consistentes con las reglas de la política, la función devuelve true y cada regla de la política se añade a la política actual.

For example:

rules := [][] string {
    []string {"jack", "data4", "read"},
    []string {"katy", "data4", "write"},
    []string {"leyo", "data4", "read"},
    []string {"ham", "data4", "write"},
}

areRulesAdded := e.AddPolicies(rules)

AddPoliciesEx()​

AddPoliciesEx añade reglas de autorización a la política actual. Si la regla ya existe, la regla no se añadirá. Pero a diferencia de AddPolicies, otras reglas no existentes se añaden en lugar de devolver falso directamente

For example:

ok, err := e.AddPoliciesEx([][]string{{"user1", "data1", "read"}, {"user2", "data2", "read"}})

AddNamedPolicy()​

AddNamedPolicy añade una regla de autorización a la política con nombre actual. Si la regla ya existe, la función devuelve false y la regla no se añadirá. De lo contrario, la función devuelve true al añadir la nueva regla.

For example:

added := e.AddNamedPolicy("p", "eve", "data3", "read")

AddNamedPolicies()​

AddNamedPolicies añade reglas de autorización a la política con nombre actual. La operación es de naturaleza atómica. Por lo tanto, si las reglas de autorización consisten en reglas que no son consistentes con la política actual, la función devuelve false y ninguna regla de la política se añade a la política actual. Si todas las reglas de autorización son consistentes con las reglas de la política, la función devuelve true y cada regla de la política se añade a la política actual.

For example:

rules := [][] string {
    []string {"jack", "data4", "read"},
    []string {"katy", "data4", "write"},
    []string {"leyo", "data4", "read"},
    []string {"ham", "data4", "write"},
}

areRulesAdded := e.AddNamedPolicies("p", rules)

AddNamedPoliciesEx()​

AddNamedPoliciesEx añade reglas de autorización a la política con nombre actual. Si la regla ya existe, la regla no se añadirá. Pero a diferencia de AddNamedPolicies, otras reglas no existentes se añaden en lugar de devolver falso directamente

For example:

ok, err := e.AddNamedPoliciesEx("p", [][]string{{"user1", "data1", "read"}, {"user2", "data2", "read"}})

SelfAddPoliciesEx()​

SelfAddPoliciesEx añade reglas de autorización a la política con nombre actual con autoNotifyWatcher desactivado. Si la regla ya existe, la regla no se añadirá. Pero a diferencia de SelfAddPolicies, otras reglas no existentes se añaden en lugar de devolver falso directamente

For example:

ok, err := e.SelfAddPoliciesEx("p", "p", [][]string{{"user1", "data1", "read"}, {"user2", "data2", "read"}})

RemovePolicy()​

RemovePolicy elimina una regla de autorización de la política actual.

For example:

removed := e.RemovePolicy("alice", "data1", "read")

RemovePolicies()​

RemovePolicies elimina reglas de autorización de la política actual. La operación es de naturaleza atómica. Por lo tanto, si las reglas de autorización consisten en reglas que no son consistentes con la política actual, la función devuelve false y ninguna regla de la política se elimina de la política actual. Si todas las reglas de autorización son consistentes con las reglas de la política, la función devuelve true y cada regla de la política se elimina de la política actual.

For example:

rules := [][] string {
    []string {"jack", "data4", "read"},
    []string {"katy", "data4", "write"},
    []string {"leyo", "data4", "read"},
    []string {"ham", "data4", "write"},
}

areRulesRemoved := e.RemovePolicies(rules)

RemoveFilteredPolicy()​

RemoveFilteredPolicy elimina una regla de autorización de la política actual, se pueden especificar filtros de campo. RemovePolicy elimina una regla de autorización de la política actual.

For example:

removed := e.RemoveFilteredPolicy(0, "alice", "data1", "read")

RemoveNamedPolicy()​

RemoveNamedPolicy elimina una regla de autorización de la política con nombre actual.

For example:

removed := e.RemoveNamedPolicy("p", "alice", "data1", "read")

RemoveNamedPolicies()​

RemoveNamedPolicies elimina reglas de autorización de la política con nombre actual. La operación es de naturaleza atómica. Por lo tanto, si las reglas de autorización consisten en reglas que no son consistentes con la política actual, la función devuelve false y ninguna regla de la política se elimina de la política actual. Si todas las reglas de autorización son consistentes con las reglas de la política, la función devuelve true y cada regla de la política se elimina de la política actual.

For example:

rules := [][] string {
    []string {"jack", "data4", "read"},
    []string {"katy", "data4", "write"},
    []string {"leyo", "data4", "read"},
    []string {"ham", "data4", "write"},
}

areRulesRemoved := e.RemoveNamedPolicies("p", rules)

RemoveFilteredNamedPolicy()​

RemoveFilteredNamedPolicy elimina una regla de autorización de la política nombrada actual, se pueden especificar filtros de campo.

For example:

removed := e.RemoveFilteredNamedPolicy("p", 0, "alice", "data1", "read")

HasGroupingPolicy()​

HasGroupingPolicy determina si existe una regla de herencia de roles.

For example:

has := e.HasGroupingPolicy("alice", "data2_admin")

HasNamedGroupingPolicy()​

HasNamedGroupingPolicy determina si existe una regla de herencia de roles nombrada.

For example:

has := e.HasNamedGroupingPolicy("g", "alice", "data2_admin")

AddGroupingPolicy()​

AddGroupingPolicy añade una regla de herencia de roles a la política actual. Si la regla ya existe, la función devuelve false y la regla no se añadirá. De lo contrario, la función devuelve true al añadir la nueva regla.

For example:

added := e.AddGroupingPolicy("group1", "data2_admin")

AddGroupingPolicies()​

AddGroupingPolicies añade reglas de herencia de roles a la política actual. La operación es de naturaleza atómica. Por lo tanto, si las reglas de autorización consisten en reglas que no son consistentes con la política actual, la función devuelve false y ninguna regla de la política se añade a la política actual. Si todas las reglas de autorización son consistentes con las reglas de la política, la función devuelve true y cada regla de la política se añade a la política actual.

For example:

rules := [][] string {
    []string {"ham", "data4_admin"},
    []string {"jack", "data5_admin"},
}

areRulesAdded := e.AddGroupingPolicies(rules)

AddGroupingPoliciesEx()​

AddGroupingPoliciesEx añade reglas de herencia de roles a la política actual. Si la regla ya existe, la regla no se añadirá. Pero a diferencia de AddGroupingPolicies, otras reglas no existentes se añaden en lugar de devolver false directamente

For example:

ok, err := e.AddGroupingPoliciesEx([][]string{{"user1", "member"}, {"user2", "member"}})

AddNamedGroupingPolicy()​

AddNamedGroupingPolicy añade una regla de herencia de roles nombrada a la política actual. Si la regla ya existe, la función devuelve false y la regla no se añadirá. De lo contrario, la función devuelve true al añadir la nueva regla.

For example:

added := e.AddNamedGroupingPolicy("g", "group1", "data2_admin")

AddNamedGroupingPolicies()​

AddNamedGroupingPolicies añade reglas de herencia de roles nombradas a la política actual. La operación es de naturaleza atómica. Por lo tanto, si las reglas de autorización consisten en reglas que no son consistentes con la política actual, la función devuelve false y ninguna regla de la política se añade a la política actual. Si todas las reglas de autorización son consistentes con las reglas de la política, la función devuelve true y cada regla de la política se añade a la política actual.

For example:

rules := [][] string {
    []string {"ham", "data4_admin"},
    []string {"jack", "data5_admin"},
}

areRulesAdded := e.AddNamedGroupingPolicies("g", rules)

AddNamedGroupingPoliciesEx()​

AddNamedGroupingPoliciesEx añade reglas de herencia de roles nombradas a la política actual. Si la regla ya existe, la regla no se añadirá. Pero a diferencia de AddNamedGroupingPolicies, otras reglas no existentes se añaden en lugar de devolver false directamente

For example:

ok, err := e.AddNamedGroupingPoliciesEx("g", [][]string{{"user1", "member"}, {"user2", "member"}})

RemoveGroupingPolicy()​

RemoveGroupingPolicy elimina una regla de herencia de roles de la política actual.

For example:

removed := e.RemoveGroupingPolicy("alice", "data2_admin")

RemoveGroupingPolicies()​

RemoveGroupingPolicies elimina reglas de herencia de roles de la política actual. La operación es de naturaleza atómica. Por lo tanto, si las reglas de autorización consisten en reglas que no son consistentes con la política actual, la función devuelve false y ninguna regla de la política se elimina de la política actual. Si todas las reglas de autorización son consistentes con las reglas de la política, la función devuelve true y cada regla de la política se elimina de la política actual.

For example:

rules := [][] string {
                []string {"ham", "data4_admin"},
                []string {"jack", "data5_admin"},
        }

areRulesRemoved := e.RemoveGroupingPolicies(rules)

RemoveFilteredGroupingPolicy()​

RemoveFilteredGroupingPolicy elimina una regla de herencia de roles de la política actual, se pueden especificar filtros de campo.

For example:

removed := e.RemoveFilteredGroupingPolicy(0, "alice")

RemoveNamedGroupingPolicy()​

RemoveNamedGroupingPolicy elimina una regla de herencia de roles de la política nombrada actual.

For example:

removed := e.RemoveNamedGroupingPolicy("g", "alice")

RemoveNamedGroupingPolicies()​

RemoveNamedGroupingPolicies elimina reglas de herencia de roles nombradas de la política actual. La operación es de naturaleza atómica. Por lo tanto, si las reglas de autorización consisten en reglas que no son consistentes con la política actual, la función devuelve false y ninguna regla de la política se elimina de la política actual. Si todas las reglas de autorización son consistentes con las reglas de la política, la función devuelve true y cada regla de la política se elimina de la política actual.

For example:

rules := [][] string {
    []string {"ham", "data4_admin"},
    []string {"jack", "data5_admin"},
}

areRulesRemoved := e.RemoveNamedGroupingPolicies("g", rules)

RemoveFilteredNamedGroupingPolicy()​

RemoveFilteredNamedGroupingPolicy elimina una regla de herencia de roles de la política nombrada actual, se pueden especificar filtros de campo.

For example:

removed := e.RemoveFilteredNamedGroupingPolicy("g", 0, "alice")

UpdatePolicy()​

UpdatePolicy actualiza una política antigua a una nueva política.

For example:

updated, err := e.UpdatePolicy([]string{"eve", "data3", "read"}, []string{"eve", "data3", "write"})

UpdatePolicies()​

UpdatePolicies actualiza todas las políticas antiguas a nuevas políticas.

For example:

updated, err := e.UpdatePolicies([][]string{{"eve", "data3", "read"}, {"jack", "data3", "read"}}, [][]string{{"eve", "data3", "write"}, {"jack", "data3", "write"}})

UpdateNamedPolicy()​

UpdateNamedPolicy update a old policy to new policy in the named policy.

For example:

updated, err := e.UpdateNamedPolicy("p", []string{"eve", "data3", "read"}, []string{"eve", "data3", "write"})

UpdateNamedPolicies()​

UpdateNamedPolicies updates all old policies to new policies in the named policy.

For example:

updated, err := e.UpdateNamedPolicies("p", [][]string{{"eve", "data3", "read"}, {"jack", "data3", "read"}}, [][]string{{"eve", "data3", "write"}, {"jack", "data3", "write"}})

UpdateFilteredPolicies()​

UpdateFilteredPolicies updates all old policies that match the filter to new policies.

For example:

updated, err := e.UpdateFilteredPolicies([][]string{{"eve", "data3", "write"}}, 0, "eve", "data3", "read")

AddFunction()​

AddFunction añade una función personalizada.

For example:

func CustomFunction(key1 string, key2 string) bool {
    if key1 == "/alice_data2/myid/using/res_id" && key2 == "/alice_data/:resource" {
        return true
    } else if key1 == "/alice_data2/myid/using/res_id" && key2 == "/alice_data2/:id/using/:resId" {
        return true
    } else {
        return false
    }
}

func CustomFunctionWrapper(args ...interface{}) (interface{}, error) {
    key1 := args[0].(string)
    key2 := args[1].(string)

    return bool(CustomFunction(key1, key2)), nil
}

e.AddFunction("keyMatchCustom", CustomFunctionWrapper)

LoadFilteredPolicy()​

LoadFilteredPolicy carga políticas filtradas desde archivo/base de datos.

For example:

err := e.LoadFilteredPolicy()

LoadIncrementalFilteredPolicy()​

LoadIncrementalFilteredPolicy añade una política filtrada desde archivo/base de datos.

For example:

err := e.LoadIncrementalFilteredPolicy()

UpdateGroupingPolicy()​

UpdateGroupingPolicy actualiza oldRule a newRule en la sección g

For example:

succeed, err : = e.UpdateGroupingPolicy([]string{"data3_admin", "data4_admin"}, []string{"admin", "data4_admin"})

UpdateNamedGroupingPolicy()​

UpdateNamedGroupingPolicy actualiza oldRule nombrada ptype a newRule en la sección g

For example:

succeed, err : = e.UpdateGroupingPolicy("g1",[]string{"data3_admin", "data4_admin"}, []string{"admin", "data4_admin"})

SetFieldIndex()​

SetFieldIndex soporta la personalización del nombre y posición convencionales de sub, obj, domain y priority.

[policy_definition]
p = customized_priority, obj, act, eft, subject

For example:

e.SetFieldIndex("p", constant.PriorityIndex, 0)
e.SetFieldIndex("p", constant.SubjectIndex, 4)

Comments are powered by giscus and GitHub Discussions. They load from giscus.app and GitHub only after you click the button below.