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

Cette rubrique fournit des exemples d'utilisation de la bibliothèque et du code de chaîne. Tout cela en supposant que Init() ait été appelé pour créer les entités d'amorçage et que l'appelant de Init() et invoke() soit "[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 l'ACL lui accordant la permission est la première dans la liste. Mais maintenant, toute personne correspondant à 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 (en utilisant son certificat) - pour essayer de créer un nouveau groupe. Comme Bob Garcia correspond à un modèle de 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 passé comme dernier argument, l'appel échouerait car il n'a pas les autorisations appropriées. Cet appel créera un nouveau groupe appelé "AdminGrp" avec les membres initiaux du groupe étant [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 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 pour une ressource

Nous pouvons utiliser cette nouvelle ressource dans notre code de chaîne pour autoriser uniquement les administrateurs à transférer un marbre en modifiant la méthode invoke() du code de chaîne Marbles de la façon suivante :

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
    …

    }

}