Exemple d'utilisation de la bibliothèque de contrôle d'accès de niveau fin

Cette rubrique fournit des exemples d'utilisation de cette bibliothèque et de ce code de chaîne. Tous ces éléments supposent que Init() a été appelé pour créer les entités d'amorçage et que le programme d'appel de Init() et invoke() est "[e-mail]". Le flux normal dans une application consiste à créer des listes de contrôle d'accès initiales qui seront utilisées pour accorder ou refuser l'accès aux autres entités.

Initialisation

Appelez Initialization() pour créer des entités d'amorçage lors de l'instanciation du code de chaîne. Par exemple :

import "chaincodeACL"
func (t \*SimpleChaincode) Init(nil, stub shim.ChaincodeStubInterface) pb.Response
{
         err := chaincodeACL.Initialization(stub)
}

Créer une nouvelle liste de contrôle d'accès

import "chaincodeACL"
...
{

**ACLMgr**  := chaincodeACL.NewACLManager(nil, stub) // Not specify identity, use caller's identity as default.

// Define a new ACL
**newACL**  := chaincodeACL.ACL{

    "AllowAdmins",   // ACL name
    "Allow admins full access",  // Description
    []string{"CREATE","READ","UPDATE","DELETE"},    // Accesses allowed or not
    true, // Allowed
    []string{"[e-mail]","%OU%example.com,"%GRP%admins"}, // Initial identity patterns
    ".ACLs.acl", // Start with bootstrap ACL

}

// Add this ACL with default identity (caller's identify here)
err :=  **ACLMgr**.Create( **newACL** , nil)

}

Maintenant que nous avons une nouvelle liste de contrôle d'accès, nous pouvons l'utiliser pour modifier qui peut effectuer certaines opérations. Nous allons donc d'abord ajouter cette nouvelle liste de contrôle d'accès au groupe d'amorçage .Groups pour permettre à tout administrateur de créer un groupe.

Ajouter une liste de contrôle d'accès à un groupe

import "chaincodeACL"
…
{

  **groupMgr**  := chaincodeACL.NewGroupManager(nil, stub) // Not specify identity, use caller's identity as default.
  err :=  **groupMgr**.AddAfterACL(

    ".Groups",     // Bootstrap group name
    ".Groups.ACL", // Which ACL to add after
    "AllowAdmins", // The new ACL to add
    nil            // with default identity that's frank.thomas

)

}

Cela ajoute la liste de contrôle d'accès AllowAdmins au groupe d'amorçage .Groups après la liste de contrôle d'accès d'amorçage initiale. Ainsi, cela garantit que Frank Thomas peut toujours effectuer des opérations sur .Groups, car la liste de contrôle d'accès lui accordant l'autorisation est la première dans la liste. Mais maintenant, toute personne qui correspond à la liste de contrôle d'accès AllowAdmins peut effectuer des opérations CREATE, READ, UPDATE ou DELETE (elle peut maintenant créer de nouveaux groupes).

Créer un groupe

Les administrateurs peuvent maintenant créer un nouveau groupe :

import "chaincodeACL"
...
{

...
  // Define a new group.
  **newGroup**  := chaincodeACL.Group{

      "AdminGrp",   // Name of the group
      "Administrators of the app",   // Description of the group
      {"[e-mail]","[e-mail]","%ATTR%role=admin"},
      []string{"AllowAdmins"},   // The ACL for the group

    }

  **groupMgr**  := chaincodeACL.NewGroupManager(nil, stub)   // Not specify identity, use caller's identity as default.
  err :=  **groupMgr**.Create( **newGroup** , bob\_garcia\_certificate)   // Using a specific certificate

...
}

Cet appel utilise une identité explicite - celle de Bob Garcia (à l'aide de son certificat) - pour essayer de créer un nouveau groupe. Comme Bob Garcia correspond à un modèle dans la liste de contrôle d'accès AllowAdmins et que les membres de cette liste de contrôle d'accès peuvent effectuer des opérations CREATE sur le groupe d'amorçage .Groups, cet appel réussira. Si Jim Silva - qui n'était pas dans l'unité organisationnelle example.com ni dans le groupe AdminGrp (qui n'existe toujours pas) - avait son certificat transmis comme dernier argument, l'appel échouerait car il n'a pas les autorisations appropriées. Cet appel créera un nouveau groupe nommé "AdminGrp", les membres initiaux du groupe étant [e-mail] et [e-mail] ou toute personne ayant l'attribut (ABAC) role=admin.

Créer une nouvelle ressource

import "chaincodeACL"
...
{

  ...
  **newResource**  :=  **chaincodeACL**.Resource{

      "transferMarble", // Name of resource to create

      "The transferMarble chaincode function", // Description of the resource

      []string{"AllowAdmins"}, // Single ACL for now allowing admins

  }

  **resourceMgr**  :=  **chaincodeACL**.NewResourceManager(nil, stub)  // Not specify identity, use caller's identity as default.
  err :=  **resourceMgr**.Create(resourceMgr, nil)   // Using caller's certificate

  ...
}

Cela créerait une nouvelle ressource nommée transferMarble que l'application pourrait utiliser pour contrôler l'accès à la fonction de code de chaîne transferMarble. L'accès est actuellement limité par la liste de contrôle d'accès AllowAdmins.

Vérifier l'accès à une ressource

Nous pouvons utiliser cette nouvelle ressource dans notre code de chaîne pour permettre uniquement aux administrateurs de transférer une marbre en modifiant la méthode invoke() du code de chaîne Marbres comme suit :

import "chaincodeACL"
…
func (t \*SimpleChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {

  **resourceMgr**  :=  **chaincodeACL**.NewResourceManager(nil, stub)   // Not specify identity, use caller's identity as default.

  function, args := stub.GetFunctionAndParameters()

  fmt.Println("invoke is running " + function)        // Handle different functions

  if function == "initMarble" {   //create a new marble

      return t.initMarble(stub, args)}

  else if function == " **transferMarble**" { //change owner of a specific marble

    **allowed** , err : =  **resourceMgr**. **CheckAccess** ("transferMarble", "UPDATE", nil)
    if  **allowed**  == true {

      return t.transferMarble(stub, args)

    else {

      return NOACCESS

    }

    } else if function == "transferMarblesBasedOnColor" { //transfer all marbles of a certain color
    …

    }

}