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

Cette rubrique fournit quelques exemples d'utilisation de cette bibliothèque et de ce code chaîne. Tous ces éléments supposent que Init() a été appelé pour créer les entités d'initialisation et que l'appelant de Init() et invoke() est "[e-mail]". Dans une application, le flux normal 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'initialisation lors de l'instanciation du code chaîne. Exemple :

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

Créer une 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 ACL, 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 de démarrage .Groups pour permettre à tout administrateur de créer un groupe.

Ajouter une ACL à 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

)

}

Cette opération ajoute l'ACL AllowAdmins au groupe d'initialisation .Groups après l'ACL d'initialisation initiale. Ainsi, cela garantit que Frank Thomas peut toujours effectuer des opérations sur .Groups car l'ACL lui accordant l'autorisation est la première dans la liste. Mais désormais, tous ceux qui correspondent à l'ACL AllowAdmins peuvent effectuer des opérations CREATE, READ, UPDATE ou DELETE (ils peuvent désormais créer des groupes).

Créez un groupe

Les administrateurs peuvent désormais créer un 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 (en utilisant son certificat) - pour essayer de créer un nouveau groupe. Comme Bob Garcia correspond à un modèle dans l'ACL AllowAdmins et que les membres de cette ACL peuvent effectuer des opérations CREATE sur le groupe de démarrage .Groups, cet appel réussira. Si Jim Silva - qui n'était pas dans l'unité d'organisation example.com ni dans le groupe AdminGrp (qui n'existe toujours pas) - avait passé son certificat comme dernier argument, l'appel échouerait car il ne dispose pas des autorisations appropriées. Cet appel crée un groupe appelé "AdminGrp" avec les membres initiaux du groupe [e-mail] et [e-mail] ou toute personne ayant l'attribut (ABAC) role=admin.

Créer une 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 ressource nommée transferMarble que l'application pourrait utiliser pour contrôler l'accès à la fonction de code 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 chaîne pour autoriser uniquement les administrateurs à transférer un marbre en modifiant la méthode invoke() du code chaîne Marbles 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
    …

    }

}