How to Build an End-to-End encryption in Hyperledger Fabric

Hyperledger Fabric has unlimited potential, and is one of the best frameworks to implement your blockchain business network in. The current version, Fabric 1.1, involves the use of CouchDB or LevelDB as storage/state/database options.

Although the network implementation considers privacy and security of data in the network as a priority, by default, all of the data that is stored in the state is plain-text. When we deal with critical data, it is always considered the best practice to not store as plain-text. It’s in the nature of blockchains to contain cryptographic signing and encryption data.

This article will explain how to encrypt and then store the data to the state, and obviously how to decrypt and use it, all in a secure manner.

Assumptions

You know how to write and deploy Go chaincode to the network, and are comfortable working with Hyperledger Fabric.

If you don’t, read through our previous articles to get settled.

Understanding Encryption Resources

Before we dive into the implementation, let’s understand what resources Fabric provides to implement this, and what their role is. If you want to get directly to the implementation, skip this section.

The packages that we’ll be using include,

BCCSP - The BlockChain Cryptographic Service Provider is the package that offers the implementation of cryptographic standards and algorithms.
BCCSPFactory - The BCCSPFactory is used to get instances of the BCCSP interface. A Factory, has a name used to address it.
Entities - An entity is the basic interface for all crypto entities that are used by the library to obtain chaincode-level encryption. This package holds many methods that implement cryptographic operations. We will be using 3 such methods, one for creating the AES256 entity, and the other two to perform the encryption and decryption.

Getting started

We will use the basic-network configuration provided in Hyperledger Fabric’s documentation , as our template. We will make use of an isolated package, making it easier to use in multiple projects. So configure your network according to the documentation.

Creating the package

Let’s create a go package with a cool name, FabCrypt, to hold the encryption and decryption middleware.

The directory structure as follows,

1
- chaincode
2
-- fabcrypt
3
----- wrapper.go
4
----- utils.go
5
--- main.go

BCCSP provides two primary functions that we’ll use here

Simple Encryption and Decryption
Signed Encryption and Decryption

We will use and implement the former for this article.

Writing Chaincode

We start by creating the primary functions, that do the main work
- Encrypt and Store to state
- Get from state and Decrypt

utils.go

1
package fabcrypt
2

3
import (
4
        "encoding/json"
5

6
        "github.com/hyperledger/fabric/core/chaincode/shim"
7
        "github.com/hyperledger/fabric/core/chaincode/shim/ext/entities"
8
        "github.com/pkg/errors"
9
)
10

11
// getStateAndDecrypt retrieves the value associated to key,
12
// decrypts it with the supplied entity and returns the result
13
// of the decryption
14
func getStateAndDecrypt(stub shim.ChaincodeStubInterface, ent entities.Encrypter, key string) ([]byte, error) {
15
        // at first we retrieve the ciphertext from the ledger
16
        ciphertext, err := stub.GetState(key)
17
        if err != nil {
18
                return nil, err
19
        }
20

21
        if len(ciphertext) == 0 {
22
                return nil, errors.New("no ciphertext to decrypt")
23
        }
24

25
        return ent.Decrypt(ciphertext)
26
}
27

28
// encryptAndPutState encrypts the supplied value using the
29
// supplied entity and puts it to the ledger associated to
30
// the supplied KVS key
31
func encryptAndPutState(stub shim.ChaincodeStubInterface, ent entities.Encrypter, key string, value []byte) error {
32
        // at first we use the supplied entity to encrypt the value
33
        ciphertext, err := ent.Encrypt(value)
34
        if err != nil {
35
                return err
36
        }
37

38
        return stub.PutState(key, ciphertext)
39
}

Let’s create wrappers for these functions, that validate the requirements. The key that will be used to encrypt/decrypt will have to be passed as a 32 byte array (AES 256 bit array). For the article, we will use a 0 filled byte array. Highly recommend to not use this as-is, please add your own key.

wrapper.go

1
package fabcrypt
2

3
import (
4
        "crypto/md5"
5
        "encoding/hex"
6
        // "fmt"
7
        "github.com/hyperledger/fabric/bccsp"
8
        "github.com/hyperledger/fabric/bccsp/factory"
9
        "github.com/hyperledger/fabric/core/chaincode/shim"
10
        "github.com/hyperledger/fabric/core/chaincode/shim/ext/entities"
11
)
12

13
// EncCC example simple Chaincode implementation of a chaincode that uses encryption/signatures
14
type EncCC struct {
15
        bccspInst bccsp.BCCSP
16
}
17

18
// Encrypter encrypts the data and writes to the ledger
19
func Encrypter(stub shim.ChaincodeStubInterface, key string, valueAsBytes []byte) error {
20
        factory.InitFactories(nil)
21
        encCC := EncCC{factory.GetDefault()}
22
        encKey := make([]byte, 32)
23
        iv := make([]byte, 16)
24
        ent, err := entities.NewAES256EncrypterEntity("ID", encCC.bccspInst, encKey, iv)
25
        if err != nil {
26
                return err
27
        }
28

29
        return encryptAndPutState(stub, ent, key, valueAsBytes)
30
}
31

32
// Decrypter decrypts the data and writes to the ledger
33
func Decrypter(stub shim.ChaincodeStubInterface, key string) ([]byte, error) {
34
        factory.InitFactories(nil)
35
        encCC := EncCC{factory.GetDefault()}
36
        // fmt.Println(encCC)
37
        decKey := make([]byte, 32)
38
        iv := make([]byte, 16)
39
        ent, err := entities.NewAES256EncrypterEntity("ID", encCC.bccspInst, decKey, iv)
40
        if err != nil {
41
                return nil, err
42
        }
43

44
        return getStateAndDecrypt(stub, ent, key)
45
}
46

47
func GetMD5Hash(text string) string {
48
        hasher := md5.New()
49
        hasher.Write([]byte(text))
50
        return hex.EncodeToString(hasher.Sum(nil))
51
}

Both of these functions specified above are out wrappers, and send in the entity that has been loaded with either the encryption/decryption key, the bccsp instance, and the IV(optional).

In our main package, we will write the testing functions to verify these modules. You can use the implementation as a simple template, to add to the next big thing you will be building.

main.go

1
package main
2

3
import (
4
        "fmt"
5

6
        eh "github.com/chaincode/errorhandler"
7
        fc "github.com/chaincode/fabcrypt"
8
        "github.com/hyperledger/fabric/core/chaincode/lib/cid"
9
        "github.com/hyperledger/fabric/core/chaincode/shim"
10
        sc "github.com/hyperledger/fabric/protos/peer")
11

12
type SmartContract struct {
13
}
14

15
func (s *SmartContract) Init(APIstub shim.ChaincodeStubInterface) sc.Response {
16
        return shim.Success(nil)
17
}
18

19
func (s *SmartContract) Invoke(APIstub shim.ChaincodeStubInterface) sc.Response {
20

21
        function, args := APIstub.GetFunctionAndParameters()
22

23
        if function == "testEncrypt" {
24
                return s.testEncrypt(APIstub)
25
        } else if function == "testDecrypt" {
26
                return s.testDecrypt(APIstub)
27
        }
28
        return shim.Error("Invalid Smart Contract function name.")
29
}
30

31
func (s *SmartContract) testEncrypt(APIstub shim.ChaincodeStubInterface) sc.Response {
32
        value := "WakandaForeva"
33
        key := "testId"
34
        err := fc.Encrypter(APIstub, key, []byte(value))
35
        if err != nil {
36
                return shim.Error(err.Error())
37
        }
38
        return shim.Success(nil)
39
}
40

41
func (s *SmartContract) testDecrypt(APIstub shim.ChaincodeStubInterface) sc.Response {
42
        key := "testId"
43
        val, err := fc.Decrypter(APIstub, key)
44
        if err != nil {
45
                return shim.Error(err.Error())
46
        }
47
        return shim.Success(val)
48
}
49
func main() {
50
        err := shim.Start(new(SmartContract))
51
        if err != nil {
52
                fmt.Printf("Error starting SmartContract chaincode: %s", err)
53
        }
54
}

Testing The Chaincode

Let’s test our chaincode with the network. Make sure that you have the cli container up and running. The flag -C specifies the channel name, -n specifies the chaincode name, -c specify the inputs we’re sending.

As you can see from the above snippet, “WakandaForeva” is the string we’re trying to encrypt.

1
docker exec -it cli peer chaincode invoke -C mychannel -n mycc -c '{"Args" : ["testEncrypt"]}'

You can navigate to http://localhost:5984/_utils/ in your browser, to verify CouchDB’s interface. This is how the record that got stored should look like.

You will not be able to see the value “WakandaForeva” anywhere here, and notice that it has been encrypted.

Let’s test the decryption now.

1
docker exec -it cli peer chaincode query -C mychannel -n mycc -c '{"Args" : ["testDecrypt"]}'

On executing this command, we get the following response -

It worked! The query result is “WakandaForeva”

So this is how we can implement end to end encryption for our Hyperledger Fabric chaincode. Comment below if you have any questions or suggestions!