►
Description
Gero Dittmann & Jens Jelitto, IBM Research
IoT devices that sign their own transactions establish a trusted channel from the device to the blockchain with no need to trust any intermediary on the way. Running an entire SDK executing the Hyperledger protocols, however, may not be possible on devices with little processing and memory resources.
The SDK Proxy is a cloud service that enables such lightweight IoT devices to sign their own transactions while off-loading the communication with Hyperledger Fabric to the proxy. This significantly reduces the footprint of the client while maintaining the trusted channel from the device to the peers.
The demo shows an IoT device signing and submitting sensor readings via the SDK Proxy to Hyperledger, peers verifying the readings' signature, and the device receiving acknowledgments for the transactions.
----
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 #HyperledgerGlobalForum2018 #Blockchain
A
1,700
we're
in
Switzerland,
so
I'll
try
to
start
on
time.
It's
already
getting
dark
outside
I
just
hope.
He
was
still
spared
a
little
of
your
attention
span
for
for
our
presentation
here,
because,
of
course,
we're
gonna
tell
you
something
exciting.
What
what
we
want
to
show
you
here
is
an
approach:
how
to
give
IOT
devices
identities
on
the
hyper
ledger
fabric
and
in
particular,
do
enable
lightweight
IOT
devices
to
do
that
too.
A
So,
not
just
raspberry
PI's,
although
that
still
is
gonna,
be
our
prototyping
platform,
but
Arduino
type
lightweight
devices
are
the
goal
here
now.
Why
is
that
a
relevant
problem
and
the
blockchain
like
like
fabric,
is
or
like
the
hyper
later,
projects
are
a
very
nice
and
useful
platform
for
business
process.
A
Automation
and
increasingly
IOT
devices
play
a
role
in
these
business
processes,
so
they
are
delivering
inputs
that
determine
the
next
step
in
a
process,
so
the
people
who
own
those
processes
would
rather
use
IOT
devices
whose
readings
they
trust
who's,
whose
input
they
have
reason
to
be
confident
in
and
an
example
is
what
you
see
here.
Let's
say
we
have
on
that
hyper
ledger
platform
on
the
on
the
right
hand:
side
from
from
from
where
are
you
looking?
We
have
an
application
that
implements
a
supply
chain,
management
process
and
part
of
the
supply
chain.
A
Management
problem
is
monitoring
a
co
chain,
so
say:
there's
a
threshold
of
10
degrees
centigrade
that
should
not
be
crossed
during
the
transport
time
of
goods
in
a
container
and
every
and
the
container
that
sits
on
a
track
here
is
equipped
with
a
IOT
enabled
temperature
sensor,
and
so
these
are
not
three
tracks.
They
say
this
is,
and
over
the
course
of
the
time
the
external
temperature
changes.
So
we
want
reliable
temperature
readings
now.
Typically,
a
temperature
sensor
is
a
very
simple
thing.
A
You
don't
need
a
full
computer
to
support
that,
but
something
like
an
Arduino,
so
you
would
like
to
have
something
on
that
on
that
temperature
sensor
that
identifies
it
towards
the
blockchain
and
that
enables
ideally
enables
the
device
to
sign
its
own
transactions
right
so
that
nobody
on
the
way
from
the
truck
to
the
blockchain
can
modify
it
and
even
one
of
the
other
peers.
On
the
other
end
of
on
some
other
end
of
the
blockchain
platform,
those
with
the
question
marks.
A
So
the
device
signs
its
own
readings
sends
the
the
signed
readings
to
the
proxy
and
the
proxy
organizes
the
communication
with
the
endorsers
collects
the
endorsements
back
then
lets
the
the
endorsed
final
transaction
again
signed
by
the
device
and
sent,
but
then
again
sends
the
results
to
the
orders.
So
that's
the
idea.
This
is
what
that
looks
like
in
a
bit
more
detail:
the
transactions
we
have.
A
A
The
final
transaction
again
is
being
sent
to
the
SDK
back-end
and,
in
fact,
to
the
orders
in
in
a
network
and
we've
implemented
that,
in
fact,
we
have
like
I
said:
that's
only
the
first
prototyping
platform,
so
raspberry
pi
with
the
sunset
that
provides
us
with
some
environment
readings
the
broker
be
using
is
running
on
the
IBM
Watson
IOT
platform.
The
proxy
for
now
is
running
on
that
laptop
there,
but
there's
a
future.
We
would
offer
that
as
a
service,
I
guess
and
we
have
a
freight
forwarding
application
running
on
on
the
fabric.
A
A
B
B
A
So
that's
quite
a
significant
saving
and
processing
power
and
always
keep
in
mind
that
anything
we
save
on
an
IOT
device
also
saves
power.
Typically,
then,
data
sent
to
the
network
of
some
four
teams
with
that
means
not
so
impressive,
but
it
is
something
and
the
data
received
from
the
network
drops
from
90
kilobytes
to
70
kilobytes
and
with
an
IOT
device.
All
of
this
is
precious
right.
The
data
bandwidth
is
precious.
You
have
to
pay
for
that,
and
the
power
issue
I
already
mentioned.
A
And
finally,
this
approach
is
that
the
mind
SDK
is
since
it's
only
a
small
part
of
the
full
SDK
when
we
want
to
port
this
to
a
microcontroller
platform
like
an
Arduino
that
is,
doesn't
have
the
same
environment
like
a
full
Linux
boss.
We
now
have
much
less
software
to
part,
then
if
we
would
have
to
port
the
entire
SDK,
and
with
that
I
hand
it
to
us
who
will
show
you
who
will
demonstrate
that
we've
actually
implemented
something.
Let's
see.
B
Okay,
I
may
have
to
do
a
little
window
tweaking
because
the
solution
doesn't
fit
yeah
okay,
so
we
have
seen
this
picture
now
before.
So
what
you
see
here
is
IOT
device,
which
is
our
just
running
and
communicating
wire.
A
wireless
communication
will
be
shown
in
these.
Clean
windows
should
be
a
second
one.
B
Let
me
bring
this
up
as
well,
so
there's
a
top
form
just
shows
you,
the
temperature
humidity
readings
that
we
are
feeding
out
of
sir,
or
do
we
have
service
for
a
PI
on
the
right
hand,
side
this
window
is
our
proxy,
which
I
will
stop
now,
which
is
running
on
my
local
machine.
So
this
proxy
now
connects
to
the
MQTT
poke
on
to
one
side
and
to
the
to
a
blockchain
implementation,
that's
sitting
in
our
cloud
environment
at
the
lab.
B
So
it's
a
it's
a
running
clock
chain,
environment
and
that's
what
I'm
going
to
show
you
next,
if
I
can
get
back
to
this
window,
which
is
this
one.
So
this
is
an
application
we
developed
last
year,
which
is
a
farmer
tracking
application
and
I'm
only
showing
here
all
the
assets
that
we
are
tracking
and
and
and
we
have
just
a
picture
stretch
where
farmer
products
are
shipped
from
manufacturer
to
two
of
the
Ziva,
and
so
the
shipper
has
accepted
the
possession
of
the
product.
B
And
if
you
look,
for
instance,
at
this
asset,
we
can
see
now
at
looking
at
the
history
that
this
company
has
assigned
to
trade
for
water
goods
for
shipping
and
the
shippin
has
accepted
possession.
So
now
this
thing
is
being
transported
and
what
we
are
doing
now
is.
We
are
acting
on
behalf
of
this
wait
for
water
and
use
this
device,
which
is
part
of
the
of
the
network
of
the
freight
for
water,
to
transmit,
actually
suicide
data
into
the
blockchain.
And
if
you
go
back
and
I
start
now,
so
let's
put
a
PI.
B
So
now
it
starts
communicating
and
you
can
see
I
mean
we
can
show
you
later
in
detail
what
it
is.
It's
kind
of
this
force
and
back
communication
between
a
Raspberry
Pi
and
the
Boxee,
and
then
the
poxy
takes
information
and
ships
it
into
the
blockchain.
So,
and
this
is
just
repeated
every
zone,
so
many
segments
going
back
now
to
our
application
and
just
reloading
the
history.
B
Six,
so
if
you
now
go
and
and
then
go
and
change
the
temperature,
we
should
also
go
and
see
the
change
in
the
temperature
readings,
and
this
is
now
actually
read
out
of
this
blockchain,
and
so
you
can
see
this
is
data
sets
put
onto
the
blockchain
physically
potentials
of
the
device
that
was
provided
by
of
chain.
So
there's
no
way
to
alter
the
state
on
the
way
to
the
system.
With
this
I
hand,
it
over
back
to
yellow.
A
Right,
so
the
question
is:
who
will
operate
the
the
middleware
layer,
so
so,
basically,
the
proxy
right?
That
is
the
main
thing
and
I
should
have
pointed
that
out
more.
The
point
is
that
we
don't
have
to
trust
whoever
operates
the
proxy
anymore,
because
the
signature
is
in
the
device
and
therefore
nobody
can
modify
the
data
on
the
way
from
the
device
into
the
blockchain,
no
matter
who
operates
it
right,
at
least
they
cannot
modify
it
without
the
signature,
not
matching
anymore,
so
weak.
A
A
B
A
B
A
transaction
in
the
sense
of
an
inspector
event
throughout
the
transportation
process
of
a
good.
So
it's
an
inspect
event.
That's
recorded
associated
this
asset,
so
some
is
in
possession
of
a
border.
He
has
to
to
report
certain
things
and
one
of
those
is
inspecting
and
now
the
device
can
be
put
on
behalf
of
this
transport
operator,
temperature
location
whatever.
So
that's
considered
a
transaction.
So
it's
really
put
into
the
blockchain
under
this
ad.
A
You
can
imagine
that
this
data,
that
is
then
trusted,
presumably
could
cause
certain
actions
in
the
smart
contract
right
going,
one
branch
or
another.
If
the
threshold
is
is
violated,
then
then
some
insurance
claim
could
be
started
or
I
mean
something
along
these
lines,
or
at
least
the
shipping
will
be
marked
as
bad
I
mean.
B
A
A
Very
relevant
question
whether
whether
the
infrastructure
we
are
proposing
makes
it
well
first
of
all,
harms
decentralization
and,
secondly,
makes
it
a
single
point
of
failure.
There's
no
reason
why
you
couldn't
introduce
multiple
failover,
I,
mqtt
brokers
and
multiple
proxies,
in
fact,
the
way
we've
implemented.
This
is
that
the
proxy
is
pretty
stateless,
except
for
the
configuration
information
towards
the
blockchain.
A
But
this
could
this
configuration
of
the
blockchain
connection
could
be
shared
between
multiple
proxies
and
then
you
could
have
failover
switching
between
them,
because
there's
no
state
between
transactions
through
the
kept
in
the
proxy
so
as
those
so
that
should
work
and
the
decentralization
aspect,
mm-hmm
I,
think
that's
more
fundamental
than
the
framework
we
are
Pro
we
are
proposing
here.
That's
a
question
of
how
many
temperature
sensors
you
have
right
as
long
as
you
have
only
one
temperature
sensor.
This
will
not
be
decentralized.
B
The
intention,
of
course,
is
to
to
submit
this
data
and
a
lot
into
the
blockchain,
but
you
could
imagine
if,
if
this
is
not
the
key
issue
here,
if
you
have
a
trusted
gateway
or
something,
you
could
also
go
there
aggregate
the
data
at
the
gateway
and
use
the
gateways
and
two
signs
of
transactions.
It
would
be
a
bit
of
a
different
model,
so
we
intentionally
here
went
all
the
way
to
the
source
of
the
data.
A
Yeah
yeah
absolutely
so.
The
question
is
how
broad,
how
broadly
applicable,
is
this,
so
the
temperature
sensors
we
only
put
in
there
as
an
example
to
make
it
more
tangible,
but
but
the
implementation
we
have
is
completely
generic.
You
could
connect
any
device
that
that
runs
mqtt
and
and
has
an
implementation
of
our
slimmed-down
SDK.
It
could
be
any
device
that
talks
to
it
so
so
up
to
you
to
make
up
new
interesting
use
cases
for
this,
okay,
I
think
we
would
still
want
to
leave
a
few
minutes
for
secure
key
I.