►
From YouTube: Fabric Private Chaincode: Enhancing Privacy in Hyperledger Fabric using T... Jeb Linton & Mic Bowman
Description
Fabric Private Chaincode: Enhancing Privacy in Hyperledger Fabric using Trusted Execution Environments - Jeb Linton, IBM & Mic Bowman, Intel
Hyperledger Fabric is a popular permissioned blockchain framework for the enterprise, which enables decentralized applications including supply chain management and trade finance. In this presentation, IBM and Intel introduce Fabric Private Chaincode (FPC), a joint effort to enable privacy-sensitive use cases in Fabric, including: analytics on medical and genetic information, sealed-bid auctions and private voting systems.
FPC enhances privacy by running the Fabric chaincode application in a Trusted Execution Environment, supported by hardware-based technology such as Intel SGX. In particular, FPC executes the chaincode from encrypted memory, thereby hiding sensitive information even from operators of Peers, and their respective organizations. Also, it enables remote Peers and Clients to verify the expected chaincode execution by means of a hardware-based cryptographic attestation.
The combination of these features enables a chaincode to maintain secret information and to authenticate itself remotely. Clients can thus establish a secure channel with the chaincode, so to transfer any sensitive data (invocation requests and responses) without exposing it to the hosting Peer. Similarly, the chaincode can store any state on the ledger, or in data collections, in encrypted form across the execution of multiple transactions. At commit-time, Peers then validate endorsed encrypted data.
From a user perspective, FPC is designed to maintain Fabric’s programming model (transaction flow, chaincode interface) and to enable the implementation using diverse Trusted Execution Environments. The presentation reports on the latest SGX-based FPC prototype and discusses plans to support additional platforms through collaborations with the Confidential Computing Consortium.
----
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 #HyperledgerGlobalForum2020 #Blockchain
A
It's
always
fun
giving
a
talk
and
one
of
the
hyper-alert
meetups
just
if,
if
for
no
other
reason,
the
fact
that
I
looked
out
and
it's
like
I,
probably
know
half
of
you
have
discussions
with
half
of
you
about
about
the
different
things
that
we're
doing
so,
it's
kind
of
like
you
know,
coming
home
and
giving
a
given
to
talk
to
a
bunch
of
people
that
you
know
that
way.
Today
we
are
going
to
talk
to
you
a
little
bit
about
fabric
private
chain
code
and
there's
sort
of
a
cast
of
thousands.
A
Well
at
least
five
that
are
working
on
the
project.
So
Jeff
and
I
are
gonna,
be
doing
the
presentation
today,
Marcus
and
Bruno
hands
up
guys.
Okay,
they
are
going
to
be
showing
you
how
awesome
and
incredibly
cool
this
is
and
a
live
demo
at
5:15
right
next
door.
So
everybody
makes
sure
that
you
know
you
pack
up
and
just
walk
like
fifty
feet
over
there
to
the
next
room
for
that
Shwetha
and
Jordan
and
Michael
Steiner
are
the
other
developers
who
are
all
part
of
the
project
as
well.
A
So
we're
really
talking
about
is
how
do
we
protect
information?
How
do
we
protect
and
limit
access
to
the
information?
So
when
we
look
at
fabric
today,
we've
got
you
know.
People
usually
talk
about
a
couple
of
different
kinds
of
things
for
for
doing
confidentiality
in
fabric.
One
is
the
basic
characteristics
of
limiting
access
to
the
information.
This
is
you
know
that
the
word
we've
been
using
and
the
architecture
working
group
is
segmentation.
A
So
we
limit
the
total
number
of
people
who
have
access
who
have
physical
access
to
the
data
and
obviously
we
can
always
use
encryption
and
what
encryption
really
is
is
limiting
physical
access
to
the
keys
that
unlock
the
data.
So
it
gives
us
a
little
bit
more
efficiency
for
access
to
it.
So
what
we
get
for
segmentation
from
fabric
right
now,
there's
sort
of
a
coarse-grained
approach,
which
is
channels
which
gives
us
sort
of
a
high-level.
A
What
we're
really
doing
is
saying
that
there
is
a
limited
subset
of
the
participants
in
this
network
who
have
access
to
the
data
and
at
a
minimum
in
the
case
of
the
channel,
it's
anyone
who
participates
in
the
channel,
so
all
of
the
peers
who
are
participating
in
that
have
access
to
it.
All
of
the
participants,
conceivably,
who
are
who
are
interacting
with
it,
have
access
to
the
information
when
we
use
the
private
data
collections,
at
least
those
who
are
participating
in
the
transaction
plus
the
endorsing
peers
have
access
to
it.
That
way.
A
When
we
do
encryption,
you
know
we
like
to
talk
about
encryption
as
being
you
know,
sort
of
this
next
level
of
access,
but
really
what
encryption
really
is
is
just
limiting
access
to
the
keys,
because
once
you
have
the
key,
you
have
access
to
the
data.
So
what
we
get
by
doing
encryption
is
instead
of
moving
around
big
chunks
of
stuff.
In
order
to
share,
we
move
around
a
little
key
and
we
can
move
the
big
chunks
of
stuff
separately,
but
as
far
as
visibility
to
the
data
still
amounts
the
same
thing
all
right.
A
So
what
happens
when
no
one
is
trusted
with
the
data
right?
That's
really.
The
core
of
what
we
want
to
talk
about
here
today
is
what
happens
when
no
one's
trusted
with
the
data
I
still
need
the
integrity
of
the
endorsement,
but
I
want
to
protect
the
access
to
the
data
so
that
even
the
host
of
the
endorsing
peer
doesn't
have
access
to
it,
and
so
what
I
want
to
do
is
to
start
with
just
some
usages.
A
They
kind
of
give
you
a
flavor
for
the
kind
of
applications
that
we're
talking
about.
When
we
talk
about
this,
this
class
of
no
one
is
trusted
with
the
data.
So
a
couple
years
ago
we
were
asked
to
do
a
prototype
using
some
of
the
private
data
objects.
Code
of
a
real-time
insurance
quotes
for
for
drivers,
and
the
basic
scenario
was
automobile.
Ownership
is
going
through
sort
of
a
transition,
especially
in
Europe,
where
we're
going
from
sort
of
long-term
on
your
car
for
10
years
build
up
a
profile
for
it.
A
You
have
a
single
relationship
with
an
insurance
company
to
something
it
becomes
much
more
transient.
You
know,
we've
got
things
like
ride-sharing
and
automobile
rentals.
That
tend
to
be
short-term.
So,
if
I'm
just
doing
ride-sharing
and
rentals
that,
how
does
the
insurance
company
develop
some
feel
for
what
my
real
risk
is,
because
the
information
about
me
as
a
driver
doesn't
exist
in
any
single
location.
A
So
you
know
one
of
the
ways
that
people
urge
that
insurance
companies
are
trying
to
make
this
work.
Is
you
know
they
give
you
the
little
dongle
that
plugs
into
your
puts
at
the
Q
QB
d,
QD
B,
whatever
it
is,
the
little
port?
That's
under
your
dashboard
right
and
any
time
you
drive
someplace,
it
watches
what
you're
doing,
and
you
know
when
you
brake
hard.
A
Aren't
we
not
me,
but
imagine
the
situation
where
I
don't
have
that
long-term
relationship
with
the
insurance
company
that
each
one
of
these
interactions
that
I
have
with
a
car
is
based
on
the
driver
profile
that
I
have
well
I
can
tell
you
that
the
way
it
works
right
now
is
you
go
into
Hertz,
and
you
say
that
I
want
the
insurance
on
my
car
from
Hertz
and
they
will
give
you
the
absolute
maximum
risk
rate
right.
So
you're
gonna
pay
through
the
nose
doesn't
matter
how
good
a
driver?
A
You
are
that's
what
you're
gonna
do
so
we
would
like
to
be
able,
in
a
situation
where
we
can
collect
all
this
information
about
me
as
a
driver
across
all.
These
are
different
vehicles
that
I'm
doing
and
I
want
to
package
this
thing
up
and
hand
it
to
an
insurance
company
well
get
to
that
hand
it
to
their
insurance
company
in
a
minute,
but
I
want
to
take
this
profile
hand
it
to
the
insurance
company
insurance
company
looks
at
it
says:
hey
look.
A
You
know
six
months,
even
though
you've
driven
nine
different
cars,
no
accidents,
you
never
speak.
You
never
speed.
You
stopped
appropriately
at
every
stop
sign.
You
did
all
the
things
you're
supposed
to
do.
We
love
you.
Here's
a
great
quote:
that's
what
we
would
like
to
be
able
to
do.
There
are
a
bunch
of
problems
with
that.
One
is
how
to
ensure
the
integrity
of
the
profile
that
I
build.
That's
out
of
scope
for
today,
but
really
the
question
becomes.
A
How
do
I
get
this
profile
to
the
insurance
company,
because
I
don't
have
a
relationship
with
the
insurance
company
right
now,
I'm
looking
for
a
quote,
I'm
looking
for
a
quote:
that's
gonna
last
for
insurance
rate
for
three
days,
while
I
rent
my
car.
So
how
do
I
do
this?
Who
do
I
trust
to
run
the
computation
that
would
match
my
profile,
which
is
all
on
my
personal
data
and
every
place
I've
been
with
some
rate
analytics
that
the
insurance
company
has
provided
in
order
to
to
generate
quotes?
A
Well,
it's
my
profile,
so
the
insurance
company
should
run
their
analytics
on
my
machine,
where
I
can
make
sure
that
my
profile
is
safe
right.
The
insurance
company
is
going
to
trust
you
to
run
their
computation
on
your
machine
and
give
the
right
answers
back.
No,
what
about
the
other
way
around
I'm,
just
gonna
ship,
my
profile
off
to
the
insurance
company
I'm,
going
to
trust
the
insurance
company
to
do
nice
things
with
my
profile.
A
Okay,
that's
kind
of
how
it
works
today,
but
none
of
us
are
really
very
comfortable
with
shipping,
our
profiles
and
our
detailed
information
off
to
insurance
companies.
Right
yes,
they're
supposed
to
get
rid
of
it,
but
do
we
really
believe
that
they
actually
are
getting
rid
of
it?
So
what
we
really
want
is
some
trusted
party
and
again
I'm
gonna
talk
for
a
moment
about
the
idealized
trusted
party.
What
I
want
is
a
trusted
party
where
I
can
ship
my
data
and
the
insurance
company
can
ship
their
analytics.
A
A
We
don't
get
to
see
the
high
value
of
the
auction
and,
of
course,
there's
no
collusion
and
the
auctioneer
is
a
completely
independent
third
party
and
completely
trusted
in
this
case,
and
of
course,
you
know,
the
examples
of
this
are
things
like
spectrum
auctions,
where
the
value
of
the
spectrum
being
auctioned
is
measured
in.
Oh
eight,
maybe
nine
digits.
A
This
is
highly
valuable
assets,
so
the
threat
the
potential
threat
is
very
high
for
it.
The
temptation
for
fraud
is
extremely
high
for
it.
So
what
we
do
right
now
is
we
basically
take
some
government
agency
and
we
put
them
in
a
position
of
authority
and
they
run
the
auction
for
us.
What
happens?
However?
Oh
sorry,
let
me
just
point
out
one
thing,
because
this
is
kind
of
the
critical
point,
which
is
that
from
the
time
I
start
accepting
bids
until
the
time.
The
auction
is
closed.
A
In
theory,
no
one
is
allowed
to
see
the
current
state
of
the
auction,
because
anybody
you
can
see
the
current
state
of
the
auction
has
a
potential
for
fraud.
Now
they
can
start
to
manipulate
the
auction.
So
what
we
end
up
doing
is
right
now
is
we
have
two
institutionally
trusts,
the
auctioneer
for
doing
that
and
okay,
we've
got
legal
recourse
and
a
bunch
of
other
techniques
that
we
can
use
to
sort
of
make
sure
things
are
done
correctly,
but
even
if
I
trust,
the
organization
do
I
trust
all
the
individuals
in
the
organization.
A
It
is
often
the
case
that
what
we
want,
even
as
the
auctioneer
is
plausible,
deniability
I,
don't
want
the
responsibility
of
being
able
to
see
the
state
of
the
auction,
because
if
I
can't
see
the
state
of
the
auction,
then
I
can't
be
held
accountable
for
any
potential
fraud.
That's
that
happens
down
the
line.
So
if
I
want
to
move
the
auctioneer
out
of
that,
that
Center
of
trust
that
I
have
to
go
back
and
I
have
to
create
this
trusted
party
again
and
what
are
the
characteristics
of
the
trusted
party?
This
should
sound
familiar.
A
We
want
to
make
sure
that
the
trusted
party
enforces
all
of
the
rules
of
the
auction
and
by
the
way,
sometimes
these
Specter
marks
are
really
complicated.
Things
and
and
Marcus
and
Bruno
are
going
to
give
you
a
little
bit
more
insight
into
the
the
kind
of
details
of
the
example
that
we
implemented
nfpc.
For
so
these
are
complicated
things.
We
want
to
make
sure
that
the
integrity
is
capped,
but
we
also
want,
especially
during
that
time,
from
the
beginning
of
the
auction
until
the
time.
The
auction
is
closed.
A
We
want
to
enforce
complete
confidentiality
on
the
data
and
in
particular
there
is
no
one
who
has
the
right
to
see
that
data.
This
made
this
auction
may
last
over
months.
So
it's
not
like.
We
can
just
stick
it
in
a
server
and
expect
the
server
to
be
continuously
running.
There
is
no
one
who's
allowed
to
see
that
data
and
we
have
to
have
long-term
persistence
of
it.
A
Okay,
so
third
example
is
organizational
elections,
so
at
okay,
I'm
staying
out
of
the
political
election
space
because
that's
like
loaded
with
a
whole
bunch
of
other
problems
with
it.
Well,
let's
just
talk
about
electing
something
like
say:
the
hyper
literate
ESC
right.
So
how
do
we
work
this
today
right?
There's
a
set
of
rules
for
who
gets
to
participate,
there's
a
set
of
rules
for
how
you
get
to
vote
and
and
how
you
sort
of
allocate
your
your
weights
on
your
votes.
A
By
the
way
you
all
should
vote
in
the
TSE
election
in
the
fall.
Does
that
work
for
you?
Okay,
thank
you.
So
this
is
lovely.
We
would
like
to
be
able
to
do
this
and
typically
the
way
that
we
do
this
is-
and
this
is
the
way
the
TSE
has
been
elected-
is
that
there
are
sort
of
an
elections
committee
which
at
least
involves
Rai
and
the
Linux
Foundation
the
hyper
letter
staff
in
order
to
manage
that
to
manage
that
election.
A
No
one
gets
to
know
when
no
one
has
the
right
to
see
the
data
that
we
exist
in
them.
Okay,
so
this
really
means
the
way
that
we
do.
This
is
we
we
trust
the
election
staff
unless
you're
the
TSA,
in
which
case
they
have
to
add
the
observers
as
well
into
the
the
trusted
computing
base.
But,
okay,
now
that
we've
removed
both
the
the
sort
of
observer
class
and
the
TSA
and
the
election
staff
from
the
trusted
computing
part
of
her
the
trusted
part
of
it.
Now
we
can
speculate
on
what
this
trusted.
A
Third
party
looks
like
again
right,
and
so
this
should
sound
familiar.
We
need
integrity.
We
need
to
make
sure
that
every
vote
is
counted.
We
need
confidentiality
in
a
particular.
We
need
confidentiality
from
the
beginning
of
the
election
to
the
end
of
the
election,
and
no
one
gets
to
see
this.
So,
let's
think
a
little
bit
just
step
back
for
a
minute
and
think
about
what
fabric
will
give
us
fabric
gives
us
the
segmentation
pieces
of
it.
We
get
channels
and
we
get
private
data
collections.
A
We
can't
because
the
peers
who
are
executing
the
code
right
now,
even
though
they
have
been
segmented
into
channels
or
the
private
data
collections
or
whatever
we
want,
they
don't
have
the
ability
to
do
this
because
they
can
always
see
in
it
and
they
can
always
be
held
accountable
for
the
information
that
they
potentially
saw
as
part
of
that
computation
so
again,
sort
of
summarizing.
What
do
we
need
from
the
trust
at
their
party?
A
We
need
to
ensure
that
the
right
chain
code
executes,
and
we
need
to
ensure
that
the
results
were
computed
by
the
chain
code
that
we
that
we
thought
was
executing.
Clearly,
we
need
to
protect
a
participants
data
from
other
participants,
all
of
those
three
we
get
from
fabric
already,
but
what
we
don't
get
is
that
last
one
which
is
at
times
we
need
to
protect
the
chain
code
data
from
everyone.
So
what
we're
proposing
is
this
thing
called
fabric
private
chain
code,
which
you
know,
fabric
plus
trusted
execution
environment,
does
really
cool
things.
A
Basically,
what
we're
going
to
do
is
take
the
chain
code
that
you
know
and
love
and
execute
it
inside
a
hardware
based
trust
that
execution
environment.
So
what
we
get
from
for
integrity
is
what
we've
been
saying
about.
Fabric
gives
us
the
endorsement
policies
we
need
for
resilience
to
attack.
We
get
the
assurances
that
come
along
with
that
te
attestation
actually
allows
us
to
do
some
acceleration
and
some
improvements
and
efficiency.
A
Again,
that's
sort
of
out
of
scope
for
this
talk
right
now,
but
there
is
some
benefit
that
we
get
even
on
the
on
the
integrity
side
of
it
for
confidentiality
again,
the
participant
or
participant
thing.
We
already
have
fabric
and
channels
and
private
data
collections
that
works,
but
the
TE
gives
us
that
last
that
last
requirement,
which
is
it,
protects
it
from
everybody
else,
we're
going
to
trust
the
encrypted
memory
that
exists
in
the
tea.
A
So
for
those
of
you
who
are
not
familiar
with
what
a
hardware
based
trusted
execution
environment
is
the
simple
way
to
think
of
it.
Is
that
it's
a
chunk
of
memory
that
is
encrypted
and
that
memory
is
encrypted
with
a
key
that
only
the
hardware
has
access
to
so
the
owner
of
the
server
the
owner
of
the
computer
does
have
access
to
the
key
that's
being
used
to
encrypt
that
memory.
A
There
are
a
couple
of
other
features
that
we
like
to
find
in
it
as
well,
mostly
related
to
to
hardware
I'll
test
a
ship,
so
the
encrypted
memory
gives
us
a
way
of
preventing
even
the
owner
of
the
machine
and
any
other
software.
That's
running
on
that
machine
from
seeing
into
some
segments
of
memory
that
we're
going
to
be
executing
out
of
which
means
we
can
put
keys
and
secrets
and
data
and
other
things
inside
this
encrypted
memory,
and
you
can't
see
in
in
order
to
manipulate
it
or
to
read
it.
A
The
harbor
based
on
test
ation,
basically
says
here's
what
we
loaded
initially
and
we
can
verify
that
what
we
loaded
initially
is
correct
and
that
it
hasn't
been
tampered
with
from
the
outside
okay.
So
it's
those
two
properties
that
are
important:
here's
what
we
loaded
we
know
and
can
verify
that
what
we
loaded
was
what
we
agreed
to
load
and
we've
prevented
any
modifications
to
that,
while
the
active
all
the
code
is
being
executed
inside
that
environment.
A
So
what
we
really
get
out
of
this
is
we
get
a
protected
place
to
execute
code
where
the
host,
the
owner
of
the
machine,
is
not
able
to
see
into
the
execution,
but
where
we
can
guarantee
the
integrity
of
the
computation
that
takes
place?
Okay,
so
just
some
common
features.
We
have,
we
get
the
confidentiality
as
we
talked
about.
We
get
the
integrity
from
the
app
from
the
measurement
that
happens
and
we
get
third-party
attestation.
The
third-party
access
station
is
really
sort
of
the
critical
part
for
trusted
execution
and
blotching
environments.
A
I
can
prove
to
you
that
I
rate
that
I
made
the
the
right
computation.
So
this
is
where
I
get
the
integrity
front,
so
I'm
going
to
turn
it
over
to
Jeff
here.
Basically,
what
I
want
to
say
is
to
conclude
my
part
of
this
is
our
goal
in
developing
FPC
was
to
make
it
as
seamless
and
transparent
as
possible
for
fabric
developers
to
take
the
chain
code
that
they've
been
building
and
run
it
inside
FPC
with
the
minimal
changes
possible.
A
B
Is
this
on
okay?
Thank
you
all
right.
So
this
is
a
brief
sort
of
top
level
overview
of
elements
that
are
added
in
fiber
private
chain
code
that
are
not
in
fabric,
but
rather
than
just
go
through
the
detail
here,
I'm
gonna
go
through
it
bit
by
bit
over
the
next
few
slides.
So
with
that
what
you
see
here
is
it
emphasizes
in
green
elements
that
have
been
added
over
and
above
what
you
already
have
in
hyper
ledger
fabric.
B
So
just
going
through
these
a
bit
at
a
time
over
here
in
the
client
you
see,
we've
got
a
an
SDK
extension
for
interaction
with
fabric
private
chain
code.
Fpc,
you
see
the
chain
code
here
now
execute
in
a
chain.
Code
trusted
execution
environment.
There
is
another
trusted
execution
environment
in
which
we
keep
a
trusted
ledger
and
we'll
talk
more
about
what
that
is
and
what
it
does.
There's
some
additional
validation
logic.
B
B
This
view
assumes
that
we
are
already
set
up,
FPC
is
already
in
place
and
what
I'm
going
to
do
is
use
this
to
walk
you
through,
not
every
technical
element
of
FPC
and
how
it
works,
but
just
sort
of
the
lifecycle
of
a
single
transaction,
because
that
shows
you
basically
how
the
system
works
and
for
those
that
want
much
more
detail
on
how
you
set
up
the
environment
in
the
first
place.
I'll
refer
you
to
our
RFC
or
we
can
talk
afterwards.
B
The
one
thing
that
I'll
point
out
here
is
the
FPC
registry
that
I
mentioned
down
here.
This
is
a
standard
go
chain
code,
but
it
records
a
view
of
essentially
a
list
of
the
chain
code
trusted
execution
environments
that
have
been
registered
in
the
system
so
without
further
ado,
we'll
go
into
a
little
bit
more
step
by
step
in
the
lifecycle
of
a
chain
code
transaction.
So
invocation
and
response
is
basically
fabric
standard
with
the
distinction
that
now
the
payload
of
the
invocation
and
the
endorsements
is
encrypted
it's
encrypted
and
authenticated.
B
Now,
when
you
do
the
invocation,
the
client
contacts
the
chain
code
through
this
little
element
here
called
the
chain
code
library
which
is
itself
a
shim.
It's
a
C++
shim
since,
as
I,
don't
recall
whether
you
alluded
to
this
or
not
in
the
initial
version
of
FPC.
The
chain
codes
have
to
be
in
C++
that'll
change
over
time.
B
B
So
when
this,
when
this
endorsement
comes
back
and
includes
that
attestation
information,
so
the
order
are
then
forwards,
the
ordered
transactions
to
out
to
the
peers
for
validation
and
in
particular
there
there's
no
there's
no
actual
changes
to
the
order
of
the
way
it
operates.
It
does
include
the
attestations
and
in
the
endorsements,
the
transaction
validation
first
proceeds
as
normal
standard
for
fabric
within,
in
addition
to
the
standard
validation,
it
executes
another
set
of
validation.
B
B
But
essentially,
in
order
for
us
to
have
a
fully
trusted
view
of
the
world
state,
we
need
the
transactions
to
be
validated
again
inside
the
trusted
execution
environment,
and
once
that
is
done,
it
then
essentially
records
security
metadata.
Basically,
a
hash
of
every
key
value
pair
in
this
trusted
ledger
that,
as
I
mentioned
at
the
beginning,
when
we
did
the
invocation
and
endorsement
that's
what
enables
every
piece
of
world
state
to
be
validated
based
on
the
trusted
ledger.
B
So
you
get
state
from
the
regular
ledger,
then
you
check
that
the
security
metadata
in
the
trusted
ledger
matches
up
if
the
hash
value
recorded
in
the
trusted
ledger.
Mashes
the
hash
value
of
the
the
information
in
the
regular
ledger.
You
know
it
hasn't
been
tampered
with
and
then
finally,
the
fully
validated
transaction
is
committed
to
the
ledger.
Okay,
with
that,
I
will
pass
it
back
to
Mick
for
the
last
couple
of
slides.
A
A
So,
for
example,
range
queries
are
rather
difficult
to
do
over
encrypted
data,
and
so
we're
not
doing
arranged
queries
for
that.
But
you
should
be
able
to
operate
on
sort
of
key
value
store
and
the
way
that
you
would
expect
to
have
to
execute
on
it
right
now.
The
the
support
is
exclusively
for
C++
on
it.
That's
mostly
because
it
gives
us
a
way
of
easily
compiling
that
code
to
execute
inside
the
Enclave.
B
A
Fabric
applications
that
way,
so
one
of
the
things
that
I
said
earlier
is
that
just
because
you
take
your
chain
code
and
deploy
it
in
F
PC
does
not
guarantee
confidentiality.
It's
not
like.
We
get
to
sprinkle
a
little
magic
dust
over
it,
and
suddenly
everything
works.
The
way
that
we're
supposed
to
work.
Some
of
the
problems
are
obvious
right.
A
So
if
I
have
a
counter,
let's
say,
let's
say
that
I
have
an
operation
which
says
give
me
the
high
bid
on
the
auction
and
that
high
bid
is
confidential
during
a
particular
period
of
time,
but
I
allow
you
to
execute
that
transaction
or
retrieve
the
information
externalize.
The
information
about
the
high
bid.
Well,
we've
evaluated
confidentiality,
but
you
kind
of
did
it
because
you
were
supposed
to
do
it
right,
because
that
was
the
way
that
you
wrote
your
chain
code.
A
So
some
of
these
things
are
pretty
obvious
right,
don't
externalize
data
that
you
expect
to
be
maintained
confidential.
Some
of
them
are
a
lot
more
subtle
right
that
there
are
some
times
that
we
end
up
with
sort
of
synchronization
operations,
so
I
know
and
I'll
speak
a
little
bit
more
from
the
private
private
data
objects,
which
is
one
of
the
sources
of
some
of
the
ideas
for
this.
A
When
we
do
things
like
a
can,
animus
means
or
a
differential
privacy
implementation
inside
the
chain
code,
and
we
want
that
policy
to
be
continuously
enforced.
There's
a
query
budget
that
goes
along
with
it,
so
the
style
that
we've
implemented
in
PDO
in
order
to
make
that
work
is
a
commit
reveal
style.
So
you
commit
to
the
query
that
you
want.
The
query.
Budget
is
decremented
that
state
gets
saved
and
in
a
separate
operation
that
verifies
the
state's
been
saved
with
the
query
budget
being
decremented.
A
Now
we
allow
you
to
see
the
results,
and
so
there
are
a
few
things
like
this:
that
we
have
to
be
a
little
bit
careful
of
how
we
design
the
applications.
So
it's
not
like
I
said
it's
not
just
sort
of
you
know,
I
just
pick
it
up
and
run
it
and
suddenly
I
get
confidentiality.
There
are
times
and
for
different
kinds
of
operations,
but
I
have
to
be
a
little
bit
careful
about
how
we
architect
it
one
of
the
things
that
we're
providing
for
you.
It
that's
in
progress.
A
Right
now
is
a
is
a
developer's
guide
for
some
patterns
for
how
to
build
confidential
applications.
They
go
along
with
them
all
right,
so
I'll,
let
you
finish
it
up.
Just
a
few
last
words,
oh
by
the
way,
did
I
mention
that
Marcus
and
Bruna,
who
are
in
the
back,
are
gonna,
be
doing
a
big
demo
on
the
sealed
bid
auction
at
5:15
in
the
room
next
door.
B
Absolutely
wave
your
hands
one
more
time
guys
there.
You
go
all
right,
well,
I'll
troop
over
as
a
gang,
hopefully
so,
with
with
fabric
private
chain
code,
you
can
write
chain
code
that
is
protected
from
view
even
from
the
peers,
from
any
participant
in
the
ecosystem.
Essentially,
it
becomes
a
trusted
party
which,
in
cases
where
you
don't
need
anybody
to
see
the
data.
B
In
fact,
you
need
the
data
to
be
protected
from
visibility
from
everybody
participating
in
the
operation,
and
this
enables
new
classes
of
DLT
based
applications
like
the
ones
you
saw
here
and
it's
interesting
just
in
conversations
we've
had
here
today,
we've
probably
found
two
three,
maybe
half
a
dozen
new
and
interesting
use
cases
I
mean
in
the
grand
scheme
of
things.
We
believe
that
trusted
execution
environments
are
going
to
be
used
more
and
more
there's
an
analogy
we
sometimes
use
to
http.
You
may
have
heard
of
some
of
us
have
heard.
B
Some
of
you
have
heard
us
say
this.
Already
years
ago,
HTTP
was
used
was
invented
basically
to
enable
secure
web
transactions
with
credit
cards,
but
once
it
became
easily
accessible,
people
realized.
Why
not
just
use
it
for
all
web
traffic?
It's
just
easier
and
everything
gets
more
secure.
We
think
over
time,
something
along
those
lines
may
happen
with
trusted
execution
environments
as
they
mature.
We
hope
to
be
contributors
to
that
speaking
of
contributors.
We
hope
that
you
will
join
us
check
us
out.
Our
repo
is
on
github
here
fabric
private
chain
code.
B
There
are
links
on
the
repo
to
the
other
resources
like
the
wiki
and
the
paper,
and
we
hope
that
some
of
you
will
bring
your
interesting
use
cases
to
us
and
join
us
and
participate
on
the
project.
Please,
please
get
in
touch
with
us,
please
troop
over
next
door
with
us
and
watch
the
cool
demo,
and
with
that
open
it
up
for
questions.
A
Between
between
Avalon
and
FPC,
so
I
picked
my
usages
very
carefully.
The
first
usage
that
we're
talking
about
with
sort
of
the
insurance
quote
because
you're
doing
essentially
a
one-time
computation
where
there's
really
no
state,
that's
managed
other
than
the
profile
and
again
I'm
will
keep
the
profile
out
of
this.
But
the
actual
computation
of
the
rates
I've
got
some
confidential
data.
I
want
to
perform
an
analysis
on
and
what
that
analysis
I
happen
in
a
confidential
environment.
That's
a
great
application
for
Avalon
as
it
works
right
now.
A
Avalon
transaction
to
transaction
and
Avalon
is
stateless
in
its
current
implementation.
Fpc
is
designed
for
stateful
interactions
right
so
as
I
accumulate.
So
with
the
auction
I
accumulate
bids
over
time,
I
do
some
computation
and
I
accumulate
some
more
bids
and
I
do
some
additional
computation.
I
accumulate
some
more
bids,
so
the
state
is
maintained
over
multiple
transactions.
A
That's
what
FPC
is
good
for,
and
so
for
the
moment
when
we're
talking
about
sort
of
stateful,
and
you
can
use
the
words
on
chain
and
off
to
and
I
really
don't
like
those
at
all,
because
in
theory,
all
endorsement
in
fabric
is
off
chain
right.
The
order
is
the
only
thing
we're
where
there's
a
notion
of
a
chain,
so
you
can
think
of
it.
That
way,
but
really
the
way
I
prefer
to
think
of
it
is
Avalon
in
its
current
form
is
stateless.
A
A
You're
right,
you
read
the
chinko,
well,
okay,
so
first
of
all,
I
would
I
would
say,
go
back
and
talk
to
those
guys,
but
basically
the
auctioneer
still
has
a
role.
The
auctioneer's
role
is
not
to
see
the
data
during
the
auction,
but
the
auctioneer's
role
is
to
invoke
the
time
to
close
the
auction
function
right.
So
the
the
different
roles,
the
chain
code,
enforces
policies
on
access
to
the
data,
even
on
the
auctioneer.
A
When
we're
building
this,
and
so
one
of
the
policies
is
you
only
get
to
close
at
once,
and
you
don't
get
to
see
anything
beforehand
and
once
you
close
it,
you
don't
accept
anything
afterwards,
and
so
you
end
up
being
able
to
say
I've
closed
the
auction.
Now
I
can
do
the
audit
ability
of
all
of
the
votes
or
all
of
the
bids
that
came
in
so
the
auctioneer
is
given
the
right
to
transition
the
state
from
open
to
closed
and.
B
A
A
So
so
yeah,
okay,
let
me
let
me
just
seal
storage.
Basically,
is
there's,
there's
a
sealing
key,
that's
stored
inside
the
Enclave,
which
allows
you
to
encrypt
data,
and
you
can
take
that
encrypt
the
data
and
write
it
to
the
disk
even
over
reboots
that
that
key
is
the
same,
and
so
as
when
I
restart
the
machine.
I
can
use
that
key
to
unlock
the
storage.
A
So,
okay,
so
so,
let's,
let's
be
clear
about
something
which
okay,
so
that
the
Pippins
question
is
what
about
a
tax
on
on
hardware-based
e's
right-
and
this
is
true
of
trustzone
and
SG
ox
and
all
of
the
others
they're
a
variety
of
techniques
that
can
be
used
to
attack
it
so
number
one
make
sure
that
you're
applying
all
of
the
mitigations
for
it
right.
Okay,
that's
the
obvious
thing
to
do.
But
the
second
thing
is
that
and
and
I'll
point
out
two
things.
A
One
is
that
the
usages
that
I'm
talking
about
the
host
of
the
piers
is
honest
but
curious
right,
so
that
what
we're
trying
to
do
is
to
execute
this
in
a
place
in
a
situation
where
what
we
really
want
is
plausible
deniability
on
it.
I
don't
want
access
to
the
machine
or
I.
Don't
want
access
to
the
data
and
I
want
to
make
sure
that
I
can
prove
to
you
that
I
took
all
of
the
security.
A
Protocols
that
I
needed
in
order
to
make
sure
that
I
can
do
that
right.
So
that's
so
the
examples
that
we're
talking
about
are
there.
There
are
no
crypto
currency
examples,
for
example
in
this
in
this
case
the
second
part.
The
second
answer
to
that
is
really
that
the
TE
is
Nevernever
stands
on
its
own
anymore
than
anything
else
that
you
have
for
security
right.
My
HSM
may
protect
my
keys,
but
that
doesn't
give
me
a
secure
encryption
environment
right
if
I
write
a
bad
application
that
doesn't
matter
how
good
my
HSM
is
write.
A
It
I
have
to
combine
the
two
of
those
together.
My
HSM
is
are
subject
to
side
channels
as
well,
if
I
need
to
go
after
it
right
so
so
what
you
really
have
to
think
of
is
the
entire
security
context
in
which
this
says
right.
So,
if
I'm
taking
my
t'ee
and
I'm
running
it
in
okay,
is
heart
here
heart's
not
here,
so
I
can
pick
on
Stanford.
So,
if
I'm,
taking
my
te
and
running
it
in
the
Stanford
grad
lab,
that's
a
very
different
situation
than
if
I'm
running
my
t'ee
on
the
IBM
blockchain.
A
In
a
hosted
service,
where
I
am
paying
IBM
to
limit
physical
access
to
the
machine,
those
are
two
very
different
things,
and
so
part
of
this
is
you
have
to
understand
the
security
context.
When
we
talk
about
te
execution,
what
we're
really
talking
about
is
the
ability
to
do
optimistic
execution
for
it.
So
it's
really
and
and
again
do
we
lose
integrity
if,
if
the
machine
is
if
the
host
is
compromised,
well,
there's
this
thing
called
fabric
and
it
has
an
endorsement
policy.
A
So
what
I
get
from
the
TE
is
to
say
instead
of
having
13
peers,
where
I
require
nine
of
the
thirteen
I
can
take
three
and
I
require
two
of
the
three
right,
so
I
get
the
efficiencies
for
it,
but
I'm
still
taking
advantage
of
for
the
integrity
purposes
of
what
I
get
from
from
the
rest
of
the
application.
So,
yes,
it's
a
very
real
threat
that
we
have
to
be
concerned
about.
It
is
one
of
many
threats,
so
we
have
to
be
concerned
about.