Hyperledger Foundation Hyperledger Global Forum 2021, 11 Jun 2021

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: Fabric Private Chaincode Tutorial - Maria Munaro, Independent & Marcus Brandenburger, IBM Research

Description

Fabric Private Chaincode Tutorial - Maria Munaro, Independent & Marcus Brandenburger, IBM Research

Fabric Private Chaincode (FPC) is a new security feature for Hyperledger Fabric that leverages Trusted Execution Technology to protect the integrity and confidentiality of Smart Contracts. In this lab the audience will learn what Fabric Private Chaincode is and how it can be used to implement privacy-sensitives use cases for Hyperledger Fabric. The goal of this lab is to educate developers with all necessary background and first hands-on experience to adopt FPC for their projects. This Lab begins with an introduction of FPC, explaining the basic FPC architecture, security properties, and hardware requirements. Moreover, we will cover the FPC Chaincode API and the applications integration using the FPC Client SDK. To complement the learning experience, the audience will interactively write, build, and deploy their first FPC Chaincode. We conclude this session with a Q/A discussion.
Sessions Details & Slides (if available)- https://sched.co/j3ch

----
Hyperledger – Open Source Blockchain Technologies

Hyperledger is an open source community focused on developing a suite of stable frameworks, tools and libraries for enterprise-grade blockchain deployments.
It serves as a neutral home for various distributed ledger frameworks including Hyperledger Besu, Fabric, Sawtooth, Indy, as well as tools like Hyperledger Avalon, Cactus and libraries like Hyperledger Aries, Ursa. Learn more about Hyperledger projects: https://www.hyperledger.org/use

Case Studies: https://www.hyperledger.org/learn/case-studies
Training & Certification: https://www.hyperledger.org/learn/training
Tutorials: https://www.hyperledger.org/use/tutorials
Webinars: https://www.hyperledger.org/learn/webinars
Events: https://www.hyperledger.org/events
Vendor Directory: https://www.hyperledger.org/use/vendor-directory

Subscribe to the Hyperledger Newsletter: https://www.hyperledger.org/newsletter

Follow-us on Twitter @Hyperledger

Learn about Hyperledger Membership: https://www.hyperledger.org/about/join

#Hyperledger #HyperledgerGlobalForum2021 #Blockchain

A

All right, hello, everyone welcome to the fabric private channel tutorial session. Today uh we are lucky to host you this session uh right now from switzerland and from argentina. uh So I'm marcus, I'm with ibm research in zurich and with me here is maria.

B

Hi, I am maria, um I am an independent consultant.

A

All right and we together, we will guide you through your first hands-on experience on on fabric private chance. If this is the first experience for you and in order to find this out, we created a poll here in the system which uh we would like to answer you to get a little bit understanding uh what uh the experience with fabric private shanghai all our audience already has. um So please go to the poll and vote all right, and in this tutorial we do. I will start with a little um yeah deep dive into the technology.

A

To answer the question: what fpc or fabric private chain code actually is, and then I will hand over to maria to do the hands-on part to show your fpc in action all right. So let's jump into uh the presentation first, so we all know about use cases which makes sense for blockchain application because they can benefit from the verifiability aspects of a blockchain.

A

However, there are also use cases which come with strong privacy requirements, think about for, for instance, an auction system or a voting system based on a blockchain where we definitely benefit from the verifiability aspect. So for voting, we can then later verify that all votes have to have been considered during the voting process. This is nice, however, those use cases they come with a strong privacy requirement for voting. We understand that all the ballots uh need to uh that. We need um to maintain the secrecy of all the ballots right for a sealed auction.

A

For instance, we also need to maintain the sequency of the bids and there are other use cases where also some parts, maybe of a contract.

A

We do not want to reveal to other part parties on the blockchain, luckily magnetic eyes. So luckily, there are already some privacy mechanisms available with hyperledger fabric, for instance, we have channel which allows us to split our blockchain into multiple blockchains, essentially and thereby separate uh the participants, uh but there's all.

A

There are also private data collections which help us to partition the the data access to certain data, um or we can just uh submit data as part of a transient field of a transaction which, in the end, does not end up in as part of the transaction on the blockchain, and those mechanisms already allows us to to cover a broad range of positive privacy. Sensitive use cases, however, um there's a problem, and but the problem is actually the data visibility at the endorsing peers. What uh what does this mean?

A

So if we think about the voting example again, if the government would run an endorsing peer for such a voting system, they would have access uh to all the ballots, even if they are encrypted in some form, because if they want to process them, they need to decrypt them.

A

So this is the problem, and in order to tackle that problem, we are introducing fabric private chain code or just fpc, which is a framework to build, deploy and run uh private jenkins hyperledger fabric and with a particular focus on such use, cases which require strong privacy requirements and in the core uh why we can do that with fabric private jacket. Is that because we are leveraging modern um hardware based trusted execution technology like intel, sgx, ffpc or for project benefits from the use of that technology in three different ways?

A

And um we therefore fabric publishing code um provides us three nice properties, so the first property is confidential compute. That means that all the transaction and the ledger content is um contain only encrypted data.

A

The second property is verifiable operation. That means that all the transactions are verified through an attestation process backed into the trusted execution. Hardware and the third property is that we can prevent data misuse because all the chain code related data is um bound to the to the use inside the trusted execution context or technology.

A

So I'm not sure if you all heard about intel, sjx trusted execution technology. Confidential computing is a new buzzword nowadays, but I try to summarize those nice properties just in a single slide, there's definitely more to explore about that technology, see on the documentation, for instance, for intel sgx.

A

um However, all that trusted execution technologies like into sjx, have have one common goal. So um the thing is that they try to isolate um a specific portion of your or a sensitive portion of your application and execute it in an isolated form in the so-called enclave or enclave, um and um this is done by leveraging um um some secure memory uh or hot yeah hardware protected memory inside uh the cpu architecture and which prevents unauthorized unauthorized access from applications outside the enclave.

A

That also means that even the administrator or the operating system of of the whole system cannot look at runtime inside uh what's going on in in such an enclave, and this gives us uh the confidentiality property and allows us to provision our enclave with sensitive data without revealing it to the host.

A

The second property we get through such an enclave is, it maintains the integrity of the execution of the application itself.

A

If we now think about, if we put a smart contact or a chain code in such a trusted execution environment, it's ensured by the hardware that the smart contract follows is its specification and as a third part, which is crucial to establish trust in an application which is executed with an enclave.

A

Is the verifiability through attestation, which allows a third party to send a challenge um to to the enclave based application in order to retrieve an attestation or cryptographic proof that it runs a specific code on a protected platform essentially and combining this with fabric chain code? We get fabric private chain code.

A

Essentially, so let's have a brief look how the architecture of fabric private jenkins looks like, so we can see on the right side. We see a bunch of peers, an ordering service and a client and a couple of clients. The clients are part of an organization and together the consortium in the beginning, agrees on the chain code definition, which includes in with fabric private chain code, the code identity of the chain code. We are executing inside the enclave in sgx language. This is also called mr enclave.

A

This is done initially, then, a chain code, enclave on the pier, is spawned provisioned with the fpc chain code, which then is executed again securely and isolated from the executing or from the endorsing peer since we're using the trusted execution environment. The peer cannot access on the code and data inside the nclix.

A

However, in order to make chain codes working, the chain code of course needs to consume. Data.

A

First is the the transaction proposal itself when it's the execution is triggered in order to protect that our fpc cloud sdk is responsible to encrypt and authenticate the arguments of a transaction proposal in a way that only the chain code, the fpc chain code can decrypt it, and the second part is the word state which is retrieved by jncode when the application logic needs to access the state and by default. um Also, all the data is encrypted when it's stored outside the checkout. That is on the word state.

A

So this basically covers basics of how fpc fabric private chain code is working, um but since this is a tutorial, we would like to target focus a little bit more today on there on the user, experience or developer experience.

A

So, um first of all, our fabric private chain code is available on github we created a rfc last year, which was accepted this year for for fabric, and now we are all the code which is uh already fully implemented um and is there to be to be tested for you in order to make your life easier, we provide you a dockerized development environment which already comes with all the software dependencies uh installed, in particular, in order to compile or build fabric private chain code.

A

We rely on the intel, sgx sdk to compile the code, which is then executed inside such a trusted execution environment, since not all not everyone has sjx capable hardware. um Also, our development environment also comes with this sjx simulation mode. So you can so you don't have to worry about getting the hardware first, you can just go to our repository.

A

Get the code create the docker container and just start playing with fabric private chain code.

A

In order to I mean developing and compiling exchange code is just one aspect. You also want to run um your chain code in a test environment. So therefore, we also provide you in that developer environment, um a test network based on the fabric samples you may already know about, but we also provide you an integration test harness for for rapid development and testing of your fabric private chain code.

A

Let's have a look. um What a fabric private shank code looks like. So, as I said, we are relying on the intel sgx sdk for compiling the actual chain code. uh Fpc check code is therefore written in cec plus. However, in order to make um or to to provide you the same, look and feel as you're already familiar with with other chance languages like go or in javascript. We also try to provide you the same experience, but just from the perspective of the c developer.

A

Of course, that means in order to write a chain code, you just have to implement an invoke method which then triggers your application logic and our fpc fpc shim allows you to access the letters um through get state and put set operation, but you there are also additional functionalities available in the shim in order to, for instance, to get the function name and the parameters.

A

Sorry, um the the interesting thing about our fpc shim is that it already takes care for you about uh the protection of the data. That means that the shim is responsible to encrypt and decrypt. The the data when, uh when get state and put state is, uh um is invoked.

A

However, uh due to security reasons, we only provide a limited shim functionality, but if you think there is something missing which prevents you from using it in your use case, please let us know we can look into that.

A

um Developing the the chance itself is just one side, as we saw in the architecture slide. We also have to look into the the client application and in order to make this as smooth as possible, we provide you the fpc client sdk for go, which is based again on top of the normal fabric, sdk for go um and extend it with the transparent, with the same mechanisms with transparent encryption for the transaction arguments, as mentioned before.

A

That allows us to protect the chain code interaction, but we also provide you with the lifecycle commands in order to to package install, approve and commit an fpc chain code.

A

And with this I give to maria for the hands-on session, thank you.

B

Thank you, marcus. um There are some questions in the qa that you might want to look at while I am start showing so marcus on what fpc is about and what we have to be able to use it.

B

So the first thing we he mentioned is that we have the repository here right, the the git repository here in the git repository. We have the readme that we can start to follow to be able to create this environment that this fpc environment.

B

I don't have on my on my laptop any sgx intel processor, so uh I have to go with the uh docker image right so to be able to do that, I first had to uh get the clone the fabric chain code, um and I no um make note of this because you have to do it.

B

um You have to use a certain flag to be able to get the whole environment set it um once you follow these um instructions, you just have to do a make run, and um then you get a docker environment, ready uh with all the spc um fpc. Sorry, functionality incorporated one of the cool things about this. Is that uh you get your your? The your directory is mounted so, while you're working on the your you.

B

If you want to um work on stuff and use your own editor, to be able to um change the samples for example, or whatever you can do it using what you already have installed and it would, it will be all automatically reflected inside of the docker image so in um what are the samples that we have here? If we look at the directory structure here in the repository, we can see that there is a samples directory in the samples directory.

B

We have categorized the different samples according to the um what their object is or objective is, if it's an application to be able to access and execute uh an fpc chain code, if it is the tanker chain code per se, or if it is that we want to add this functionality to an environment.

B

So in right now, what I'm going to show you is? How would if we want to write an fpc chain code and when we want to start with a sample, we could um choose the hello world sample in this hello world sample. We have here the the code that we should follow in this uh sample.

B

What you do is you develop the chain code, you launch the fabric network, you install it and you instantiate it in a um a very reduced environment, with only a peer so that you can try it out and then in the transactions using um the two functions of the transactions store asset and retrieve asset.

B

This in in in this tutorial, we um invoke these transactions using the um peer command and line interface, fpc extension and also using the fpc client sdk for go okay. So I like to use um vs code, so I have um here in in the tutorial. We explain everything that you have to create and you can go through that, but I have already set up here the different files that we would need.

B

The first one is the the chain code per se, the program, and here we can see the hello world uh chain code, and we can see here in the invoke transaction that we are here, calling the function and we are calling it. We are calling store asset and if it's retrieve asset, we are calling retrieve asset and if we go and look at these functions store asset and retrieve asset up here we can see that we are using, put state and get state, so it's the same functionality that we usually see in fabric environments.

B

Okay, so once you have created the hello world, uh you need to compile it and we also provide the files, the definition, the cmake lists and the make files so that you can compile it and you want to test it. So we also give you an um a script that lets you create an environment where here you can see that we are going to um execute the the same.

B

The similar commands, as you would in in in an uh in uh fabric environment, to be able to package install approve, um commit um approve from organization and commit a chain code, and we also have the uh the um on a special another uh instruction to be able to start that enclave. That marcus was talking about, and then you can invoke the chain code um here. In this case, we are invoking- and you can see that here it is invoking and that we can see.

B

Function and the value- and the important thing is that, under the covers, when fpc receives that it encrypts it and stores it encrypted. So, even though we might be seeing it here in the clear um fpc handles um everything so that it is um encrypted now you would normally I said this comes, and you you, we get a small environment right, and what we wanted to show you here is how you can write. Why use that?

B

Okay, that wouldn't be as exciting as if we could show you how you could incorporate this hello world chain code in an actual environment right, because we don't usually our fabric environments, don't con aren't uh consists only of one peer. So what um what we did is we and I'll show you here again in.

B

The created another sample in inside of the deployment for the test network, where you set up a test network based on the fabric samples and what we do there is add. The efpc functionality add this chain code so that the encode that is executed in this environment is the one that we've developed. So following this tutorial changing only here where it says um echo to hello world, um I was able to uh set up an environment.

B

Okay, and if you follow this tutorial here, it offers you down below it offers you here the possibility to use a uh a go um program that has the fpc that you is using. Sorry, the fbc client sdk for go to be able to enter, and if I go back here to sorry to vs code- and I show you the application.

B

So here is the code of the um of the fpc of of this application that is connecting using the fpc client sdk, and we can see that here I am connecting like. I would in any environment I am connecting to a gateway. I'm I'm I'm getting my credentials from my wallet and then I am getting the contract.

B

This is all part of um what we have included in the fpc client sdk for go, so they are similar um apis as you would have in fabric, and here we have uh a small well according to what um fpc, if it's echo or if it's um hello world, what we are going to invoke here again you're, going to see that we have store asset asset, one asset, one with a value 100, and that we submit the transaction okay, the same as your functionality as you have um in fabric, where you can invoke a submit transaction or evaluate transaction.

B

You have here now. If I go to my environment here, I can run this as you can see, as I've already ran it here, I can run it. I can change here the organization that I am going to be running it against, and we are going to see that it says that it is invoking the uh fabric private chain code, hello, world and that the result is okay, but um you might say hey, but how do I know if it's go it's encrypted or if it isn't encrypted? Okay, how?

B

um I want to believe what you're saying so what we uh did is what I did was I added to this test network blockchain explorer. And if I go here to the explorer and let me log in again so that it can show.

B

Us so here this was following the hyper, the the the blockchain explorer tutorial. It was quite simple to add it, and here I'm going to be able to see the transactions that uh were executed, and here I can see these are the normal, the life cycle, ones that we saw where we, um where we install we we approve, we commit all those that are here and then we see the specific one for um for fpc when it registers to be able to uh obtain the credentials, and here we can see the hello world.

B

And here, if I look at the hello world, I can look down below here and see the uh the values. So here we can see asset 1 and that the value is um y um y, three mg. So it's not a hundred like we saw that it is in the code. Okay, so we can see that here it is encrypted and if we look at the following one and look at the value there.

B

We can also see that it is that um it's who whomever is looking at the ledger is not going to easily be able to deduce what the values are, because both we have hard coded 100 and the value that we are obtaining is totally different with this here's, the other one that I run. Look it just that we can see that it is running that ran and that it also is giving another value.

B

The good thing about this is that I could come over here and say: okay, let's change this and let's put 200 here and let me save and here to the terminal and run it again.

B

And we let it run, it is taking its time because it's sleepy like I am it seems we are going to see it populate here, another transaction and if I look at its value, it is going to be totally.

B

Different, I just have to wait.

B

B

Show us until it runs.

B

It wants to go to sleep, it seems just like. I would like to go to sleep.

A

Too early in argentina.

B

Yeah the computer knows it.

B

um I don't know if you want to take the time and reply some of the um answer. Some of the questions.

A

Yes, so uh let me also share the screen again, so I can okay.

B

A

The last slide again, yes,.

B

A

All right, um so thank you, murray again for that uh hands-on presentation on fpc. I I think uh we all now got an intuition what what it takes to to write an fpc j code, compile it and then run it using our test network. So, as we are mentioned, we have on our github repository. We have a bunch of readme which guides you through the process of writing the code.

A

There were some question and one question was about: oh no, there are more questions. One question was about any production case of fpc and so there this is a nice question. So I would highlight another session today where uh andrew and bruno will talk about a potential use case of fpc and which is integrating fbc into an existing system, um so join the session, bringing trust and privacy preserving smart contracts to clinical trials and healthcare.

A

um But I would also like to emphasize that um right now we are. We are working towards a production ready code of fpc, but the code is already feature complete in a way that you can already start testing it and doing using it for pocs. But right now we do not recommend it for uh for production.

A

At this moment, let me see what other questions we had.

B

There's a question that I um was asking: if it does take this long, ricardo vaso is asking if it does take this long to run the transactions and no it doesn't. But um I have a lot running on my laptop and with the video streaming and it all it is. I don't have that much memory on my laptop.

A

Yeah, so the uh there was also another question about the overhead of fpc. um Fpc definitely introduces some overhead because by default we are encrypting all the inputs and the output that takes some time as well inside the chain code during the endorsement, but also on the client side, when the arguments are encrypted before they are sent to the endorsing piece. That, of course, introduces overhead. However, the actual overhead introduced by uh the sgx technology is more or less negligible, so we have a.

A

We have a scientific paper linked also on our repository, which um also addresses uh some performance evaluation, uh often, let's say earlier: architecture, fpc uh and and there it turns out that uh there are other bottlenecks into fabric or into the communication between the checkout and the the word state, which introduces more overhead than executing the actual trinket inside the enclave.

A

So there's another interesting question: would the sjx emulator be appropriate for production, or would you recommend just use it for the development? Only so the sjx simulation mode is not meant to use for production. So if you run something with the sjx simulator, it's not secure. It's just for for developing purpose.

A

So for for running it securely with sgx, you actually need sdx, capable hardware.

A

Another question is any one click deployment package available to test like docker or vagrant- um I wouldn't say one click deployment packages, but with our docker setup we we tried to go into that direction. At the moment we are, we are not uh distributing a pre-compiled docker image, um so that means right now you have to to clone our repository and build the the docker images by yourself, which takes a couple of minutes, but uh it's fine. I I hope, as a start.

A

B

There's another question about the overhead that in the paper you say it's 10 20, for an auction app and could this overhead scale with more complex applications.

A

Well, I think then, in the paper we are, we are talking about uh a single, a single, the overhead of a single chain code. I mean the the way of uh scaling in general with fabric is, if you're it's, the processing of your tanker takes much time.

A

You need to scale you just spawn multiple or add more endorsers, which can then execute the chain code right, um but so the um I think, the the crucial part which uh which makes your application slow in general for a normal chance, but also for the fbc chain code, is, is uh whenever the jenkins needs to access the world state.

A

So whenever you perform the get state operation, this is really expensive uh operation with normal checkout and with fabric private chain good, because what what needs to happen is that the chain code communicates back to the pier via grpc. Ask hey: can you please look into the into the word state? Is there a key which I provide you um and then the peer needs to go to the database depending on the implementation of the word uh state database?

A

It takes more time I don't know, and then we have to communicate those data back and on top of that with fbc. The data then also needs to be decrypted when it's read into the chain code, so ah yeah. So I'm struggling a little bit here being more precise on in terms of percentage overhead. Here um we have not yet really evaluated the the current implementation to see what are the uh the limits of fabric private change.

A

We are right now focusing more on the functionality and try to improve the um the feel for the end user in order to simplify the adoption of fpc.

A

So we are over time, but so I'm happy to answer more questions, but if you guys need to leave to go to another session, um we can. We have also um the chance to take uh things offline. You can either visit us on the hyperledger rocket, chat and fabric private chain code, or we can also interact here in the hope in app. Somehow I guess and continue discussions.

B

Yes and the important thing I don't know marcus is, if you have referenced them to the session, um uh that's going to be later today, where the there's going to be a use case presented.

A

Right, I I think I said that, but.

B

Okay, sorry, I was sorry saying that.

A

Again, that's that's good, um I don't know so mark can. Can we answer those questions here in the in the q and a later and people who ask those questions can see that.

A

Mark your action is required as a moderator here.

B

Yes, you said yes.

A

He said yes in the chat. Yes, I just look at the q, a okay, so so then I propose that we conclude now this session.

A

uh I hope uh everyone learned something about favorite private jankart and visit our github repository and if you feel something is missing, just create an issue or feature request and let us know so we can further improve fabric private changer to make it more usable than it is right now. Thank you so much.

B