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 chaîne. Ces exemples supposent tous que la fonction Init() a été appelée pour créer les entités bootstrap 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 la fonction Initialization() pour créer des entités d'amorçage lors du déploiement de codes 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 administrators 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)

}

Vous pouvez utiliser la nouvelle liste de contrôle d'accès pour modifier qui peut effectuer certaines opérations. Ajoutez d'abord 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 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'amorçage .Groups après l'ACL d'amorçage initiale. Ainsi, Frank Thomas peut toujours effectuer des opérations sur le groupe .Groups car l'ACL qui accorde la permission Frank est en premier dans la liste. Désormais, toute personne qui correspond à l'ACL AllowAdmins peut effectuer les opérations CREATE, READ, UPDATE ou DELETE (elle peut désormais créer des groupes).

créer 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 (Bob Garcia, en utilisant son certificat) pour tenter de créer un groupe. Etant donné que 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 bootstrap .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 réussi son certificat en tant que dernier argument, l'appel échouerait car il n'avait pas les autorisations appropriées. Cet appel crée un 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 administrators

  }

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

  ...
}

Cette opération crée une ressource nommée transferMarble que l'application peut 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

Vous pouvez utiliser cette nouvelle ressource dans votre code chaîne afin d'autoriser uniquement les administrateurs à transférer un marbre, en modifiant la méthode invoke() du code chaîne Marbles comme indiqué dans le code suivant :

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 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
    …

    }

}