0

i'm new to serverless architecture in general, and i'm studying migrating my current php/mysql rest api to serverless arch.

my main concern is access control.

in certain app, i allow users to access content based on role, and groups they are assigned to "

example

role: user groups: [1,2,3] can only access content with group_id: 1 || 2 || 3

is it possible to do such access control in serverless databases like faunadb ?

Zalaboza
  • 8,899
  • 16
  • 77
  • 142

1 Answers1

2

It is possible to do such access control with FaunaDB and much more with the ABAC system (https://docs.fauna.com/fauna/current/security/abac.html)

Roles:

In essence you have Roles and these roles provide permissions 

CreateRole({
  name: "access_todos",
  privileges: [{
    resource: Collection("todos"),
    actions: {
      create: true,
      update: true,
      delete: true,
      write: true
    }
  }]
})

(you might notice that this of course gives access to all groups which is not what you want, we'll get to that)

Roles can be assigned to different things:

  • Keys: simply make a key with that role and that key can only access the groups collection
  • Functions: a User Defined Function (like a stored procedure) can assume a role.
  • Entities in a collection or part of a collection: any entity (e.g. Users, ShareLinks, Accounts) could be assigned a role by adding a 'membership.

Roles Membership (assign roles to a database entity):

You assign a role to database entities by using the membership field. In this case, all accounts in your database will have these privileges. You can also use a function here to filter out a certain type of account etc..

CreateRole({
  name: "access_todos",
  membership: [{ resource: Collection("accounts") }],
  privileges: [{
    resource: Collection("todos"),
    actions: {
      create: true,
      update: true,
      delete: true,
      write: true
    }
  }]
})

Assume the identity of that entity, (get a key for that database entity):

Then that leaves us with the question: "how do we assume the identity of a user?". We use login for that. First you create an account with a password: 

Create(
    Class("account"),
    {
      data: { email: "alice@example.com" }
      credentials: { password: "secret password" },
    }));

The important part is the credentials.password field which is a special field for FaunaDB. It will be encrypted and when a database entity has such a password you can use Login to assume the identity of the entity:

Login(
    Index("accounts_by_email"), "alice@example.com"),
    { password: "secret password" })

Login will provide you a token and that token will now have all the rights that this account has. Or in other words all the privileges of the roles for which this database entity of the collection 'accounts' is member (and membership is defined on the role with the membership key)

The power of Role predicates and the 'Identity()' function

Ok but how do we get more fine-grained access? Roles can have lambda predicates instead of booleans. That means in your case you could store the array of groups on the user (or vice versa) and link the account to the user. 

privileges: [
  {
    resource: Collection("Groups"),
    actions: {
      read: Query(
        Lambda("groupReference",
          // Write your logic
        )
      )
    }
  }
]

In such a query, the lambda parameter is the reference of the entity you try to access (e.g. a group) One question remains.. how do we check whether the user linked to an account has access to the groups? Well we use 'Identity()' for that which is an FQL function that returns the reference of the currently logged in database entity.

Note: by default you get read/write access to the entity you are logged into. Hence you do not want to store the group ids on the account since a user could in theory change these. This is why I split account and user in my explanation. We will probably change this in a future FQL version since this appears to be confusing/cumbersome.

A few good resources: - ABAC docs: https://docs.fauna.com/fauna/current/security/abac.html - ABAC with GraphQL: https://medium.com/fauna/abac-graphql-6e3273945b1c - Authentication docs: https://app.fauna.com/tutorials/authentication#creating-users

We are building a complete example as we speak which I expect to appear on our blog in the coming weeks.

Brecht De Rooms
  • 1,802
  • 7
  • 15