►
From YouTube: Rust Linz, November 2020 - Claus Matzinger - Trusted Computing with Rust and Intel SGX
Description
DISCLAIMER: Due to some technical challenges the video image started to flicker as the video progresses. Sorry for that.
Trusted Computing with Rust and Intel SGX
Do you like a challenge and at the same time don't trust the cloud? Then this talk is for you!
Working without the standard library is a core (no pun intended) aspect of Rust - and it's useful for many things, including embedded development, WASM, and working with encrypted computation such as SGX. In this talk we'll look closer at the latter: Intel's Software Guard EXtensions (SGX) and how we can get started running (mostly) safe no_std code hidden from the eyes of your cloud provider.
About Claus Matzinger
Claus Matzinger is a software engineer with a very diverse background. After working with several legacy programming languages early on, a database start up (Crate.io) was the stepping stone towards sophisticated data pipelines. At Microsoft, two years later, this should prove useful where Claus helps customers build machine learning pipelines, sort out their MLOps, and the occasional modelling. Along the way, Claus has written two books about the Rust programming language and blogs at https://blog.x5ff.xyz.
Rust Linz at https://rust-linz.at
Twitter: https://twitter.com/rustlinz
Follow Claus: https://twitter.com/0x5ff
Speak at Rust Linz: https://sessionize.com/rust-linz
B
Screen
nice
for
those
of
you
who
are
who
don't
know:
klaus,
we
in
in
the
rust
lint
swap
up
rust,
lintz
meetup.
We
always
try
to
combine
some
international
speakers
and
some
locals,
and
today
klaus
is
both.
So
we
found
the
holy
grail.
He
is
kind
of
local
and
kind
of
international
speaker
because
klaus,
if
I
remember
correctly,
you
are
from
austria,
even
from
upper
austria,
that's
correct.
B
A
All
right
so
yeah
welcome
to
from
a
web
assembly
to
another
topic
that
is
a
little
bit
more
down
to
the
metal.
In
this
case
it's
trusted
computing
with
rust
on
intel,
sgx
and
yeah.
This
is
also
similar
to
webassembly.
It's
no
std,
but
webassembly
has
already
the
the
the
working
group
has
already
done
a
good
job
on
translating
most
of
the
things
in
there
that
come
with
the
standard
library.
So
yeah.
As
you
took
you,
you
already
took
that
sort
of
forward.
I
grew
up
in
the
close
to
lynch.
A
I
lived
now
in
amsterdam
and
I've
yeah.
I've
not
lived
in
austria
for
like
seven
or
eight
years
so,
but
in
the
meantime
I've
written
two
rust
books.
You
can
find
the
the
links
to
that
on
my
blog.
It's
about
algorithms
and
data
structures
and
the
rust
cookbook
yeah.
So
I
do
all
kinds
of
different
areas
in
that
respect.
A
So
yeah
what
is
trusted
computing?
I
think
everybody
kind
of
knows
the
tired
already
saying
that
the
cloud
is
just
someone
else's
computer,
but
the
reality
is.
You
cannot
really
make
sure
that
what
you
run
on
someone
else's
computer
is
actually
what
you
wanted
to
run
and
that
nobody
is
really
sort
of
listening.
A
A
What
would
be
so
crypto
finance
is
a
fairly
recent
one,
but
in
general
finance
a
particular
example
is
something
called
the
town
crier
architecture,
which
makes
sure
that
the
data
you're
receiving
on
a
machine
and
you're
basing
your
financial
decisions
on
are
not
being
spoofed
by
an
intermediary
party
right.
So
you
make
sure
that
the
with
tls
encryption
that
the
the
the
origin
of
your
data
is
really
that
the
the
data
that
you
are
like
intending
to
to
get
right.
A
So
the
other
person,
the
other
party
is
saying,
is
really
who
do
you
say
they
are?
And
the
second
thing
is
that
the
code
that
is
making
your
financial
decisions
and
potentially
you
know,
betting.
Your
livelihood
on
something
is
really
the
code
that
you
wanted
to
run
and
not
something
that
you
know
some
root
user
that
you
never
intended
to
have
kind
of
is
changing
or
altering
this
code.
A
A
So
until
wanted
to
come
up
with
a
solution
to
that,
and
they
have.
They
have
worked
on
that
since
2015
and
the
work
is
ongoing
and
it's
called
a
software
guard,
extensions
or
sgx
for
short
and
it's
an
encrypted
cpu
enclave.
So
what
that
really
is
is
a
part
of
the
cpu
and
a
separate
instruction
set
that
is
encrypted
in
at
runtime
and
at
rest.
A
A
I
have
come
across
that
recently
in
a
in
yeah
in
the
consulting
work
that
I
do,
and
it's
really
interesting
to
see
sort
of
what
that
yeah,
how
to
how
that
is,
has
a
really
particular
influence
on
on
the
the
way
you
program,
especially,
this
is
all
hardware.
So,
if
you
think
about
like
your
hardware,
your
cpu
has
extra
two
extra
keys
that
are
to
come
out
of
the
factory.
Really
one
is
called
the
root
provisioning
key
rpk
and
that
is
sort
of
intel's
master
key.
A
So,
by
extension,
you
don't
you
know,
you
don't
trust
your
cloud
provider,
but
you
have
to
trust
intel
on
that
and
the
second
one
is
the
the
rsk
the
root,
not
the
sealed
key.
Essentially
the
root
sealed
key,
and
that
is
specific
for
your
cpu
so
and
that
is
also
unknown
to
intel.
But
it's
derived
from
the
provisioning
key.
The
the
part
that
in
memory
that
is
really
encrypted
is
part
of
the
regular
ram
right.
A
So
then
you
need
really
that's
a
really
in-depth
attack,
so
programming
for
sgx,
obviously
that's
a
c
and
c
plus
plus
territory,
and
since
everything
is
encrypted
and
everything
uses
its
own
cpu
instruction
sets
and
works
on
a
specialized
set
of
memory
it.
It
has
to
generate
proxies
right,
so
you
cannot,
you
have
to
dynamically
link
to
a
library
and
that
library
has
proxies
generated
for
each
function.
That
is
publicly
exposed,
and
this
is
typically
done
with
an
enclave
definition,
language
or
edl.
A
For
short,
and
you
declare
those
interfaces,
the
build
script
generates
those
proxies,
and
then
you
can
sort
of
use
it
as
a
normal
library
and
yeah
intel
provides
a
nice
developer
manual.
That's
only
400
pages
to
get
into
it
quickly,
yeah.
So
an
application,
an
sgx
based
application,
has
two
parts
and
trusted
part,
and
then
untrusted
part.
So
the
trusted
part
is
anything
that
runs
inside
of
the
enclave.
A
So
how
do
you
communicate
between
those
two
parts?
These
two
parts
can
be,
you
know,
can
call
each
other
called,
and
those
things
are
called
e
calls
so
into
the
enclave
and
o
calls
out
of
the
enclave
and
yeah.
The
proxy
proxy
generation
is
done
by
the
build
script
and
creates
a
yeah.
It
generates
the
code
that
can
then
ultimately
be
called
yeah,
as
this
is
no
std,
so
everything
is
encrypted
by,
and
this
means
it
needs
a
specialized
memory
allocator,
and
that
means
also
that
yeah,
you
can
maybe
translate
some
things.
A
You
can
still
have
like
vectors
and
strings
and
stuff
like
that,
but
they
can
be
limited
by
this
allocator
that
that
is
being
provided
there
and
yeah.
It's
it's
a
little
bit
different,
but
it's
a
it's
also
quite
similar,
there's
a
link
at
the
end
for
people
who
want
to
get
really
deep
into
this,
how
the
memory
pages
look
like
and
what
the
thread
memory
allocation
pattern
looks
like.
So
you
know
to
get
really
to
really
look
at
memory
layout,
diagrams
and
well.
B
A
A
A
A
This
is
called
local
at
the
station
and,
if
you
do
that
with
a
web
service
which
intel
provides
and
also
all
the
cloud
providers
that
that
provide
these,
these
yeah
machines,
they
also
provide
a
remote
at
the
station
service,
which
is
a
web
service
where
you
can
just
send,
send
the
signature
and
have
it
have
it
sort
of
a
thumbs
up
a
thumbs
down
that
this
is
running
on.
This
has
been
running
in
a
specific
enclave,
so
this
is
a
sort
of
a
short
diagram.
How
this
works
right.
A
Do
you
see
your
application
that
calls
into
the
enclave?
Does
some
stuff
signs
it
with
the
assigns
this
user
data,
with
a
special
key
that
is
from
somewhere
gives
it
back
to
the
application,
has
maybe
a
different,
so
this
is
from
a
specific
application.
So
this
has
two
enclaves
here
and
then
the
challenger
is
the
person
or
you
know,
someone
who
wants
to
know
is
this
real
and
sends
this
this
user
message
essentially
into
through
the
attestation
verification
and
can
then
say
yeah?
A
Apparently
so
they
came
up
with
a
rust,
sdk
and
rust
in
general
is
a
good
fit,
and
I
think,
given
the
memory
safety
for
this
type
of
application
and
in
the
meantime,
so
I
think
it
was
baidu
labs
and
it
was
at
a
rust,
fest
presentation
in
rome.
I
think,
which
is
a
two
years
ago
or
something
and
after
that
it
got
picked
up
by
apache
in
the
incubator
and
it's
under
active
development.
So
it
has
a
new
version.
A
Every
couple
of
weeks
and
yeah,
you
can
find
it
on
github
and
we'll
walk
through
this
sdk
in
a
minute,
so
you'll
be
proficient
in
using
it
and
jumping
in
right
away.
So
the
requirements.
What
do
you
need
to
to
run
sort
of
this
code
so
for
mac
and
windows?
You
do
need
docker
and
run
docker
containers
because
that's
for
software
emulation
of
that
of
the
driver,
so
the
rust,
the
rust
sdk
does
not
yet
work
with
windows.
A
There
you
have
to
stick
to
c,
plus
plus,
and
the
mac
doesn't
expose
the
intel
sgx
drivers
at
all.
So
if
you're
wanna
getting
get
into
compiling
your
own
drivers
for
the
mac,
I'm
sure
that
there's
a
lot
to
be
learned,
but
this
the
easiest
way
is
to
run
baidu
stock,
a
container
using
yeah
using
software
emulation
of
the
of
the
enclave.
A
A
B
A
So
so
into
the
sgx.
The
trusted
compute
platform
is,
I
think,
intel
exclusive,
but
every
like
most
websites
that
that
I
read
said
that
amd
has
something,
but
it's
not
not
as
extensive
so
and
I
didn't
find
what
it
was.
I
think
it
has
some
minor
parts,
but
right
now
I
have
not
seen
anything
that
is
sort
of
that
you
could
use
in
both
on
both
like
processors,
unfortunately
yeah
so
the
rust
sdk
itself
is
is
quite
extensive.
Already.
It
has
many
patched
versions
of
std
classes
and
structs
in
there.
A
It
has
a
ton
of
yeah
different
different
codes
like
code
and
it's
quite
complex
in
that
it
provides
specialized
versions
of
the
threads
and
also
some
vectors
and
or
the
vector,
and
I
think
the
hash
brown
hashbrown
grade
crate
and
some
of
the
cryptography
stuff
in
there
as
well.
So
you
can
use
basic
crypto
cryptography,
although,
for
example,
russ
tls
also
has
a
no
std
version
that
also
works
really
well
in
in
the
enclave.
A
Unfortunately
not
websockets,
though.
So,
let's
look
at
some
of
the
examples.
So
the
website
is,
everybody
knows
github
and
everything
is
on
github
so
fairly
recently
they
released
version
113
of
the
sdk
and
yeah
the
sdk
itself,
as
you
can
see,
there's
a
ton
of
stuff
that
that
this
sort
of
trying
to
emulate
sd
std
and
you
know
specific
types
that
also
kind
of
yeah.
You
need
like
sealing
and
unsealing
and
stuff
like
that.
That
is
here
for
for
working
with
the
enclave.
A
A
A
little
bit
larger,
so
in
this
case
this
is
a
this
is
a
azure
confidential,
compute
vm.
So
I
didn't
run
this
locally
because
I
messed
up
the
drivers
which
yeah
happens,
and
it
also
it
runs
best
on
ubuntu
and
this
I'm
running
here,
fedora
so
yeah,
that's
it.
It
does
work
on
fedora,
but
not
in
the
same,
like
it's
easier,
better
compatible
with
ubuntu.
A
The
sample
code
that
they
provide
is
is
much
better
than
whatever
I
could
come
up
with.
As
a
as
an
example,
and
in
fact
the
company
I'm
working
with
is
basing
a
lot
of
their
code
also
on
the
sample
code,
because
it
is
quite
complex
to
to
program
anything
that
works
with
works
with
their
build
system.
Specifically,
so
you
can
see,
there's
a
there's,
a
few
examples
in
there
like
starting
from
a
regular
hello
world
that
is,
this
is,
I
think,
actually
c,
plus
plus
mostly
but
there's
a
hello
rust.
A
That
is
completely
done
in
rust.
Debugging
is
interesting
because
in
a
production,
enclave
debugging
is
actually
impossible
to
do
so.
There's
no
way
to
attach
you
know
a
gdb
or
something
like
that
to
to
the
debug
symbols
of
the
running
of
the
of
the
yeah
of
the
running
code.
One
interesting
thing
is
also
tls
that
we
are
going
to
look
like
look
at
so
the
tls
is
is
verifying.
You
know
that
the
remote
party
is
the
remote
party
by
just
making
sure
that
the
certificates
match,
for
example,
you
do.
A
If
you
do
that
in
the
enclave,
then
you
actually
have
have
an
encrypted
data
stream
that
the
outside
party
cannot
read.
So
anyone
outside
of
the
enclave
cannot
read
what
you
are.
You
know
what
you're
exchanging
there
there's
also
some
machine
learning
for
those
of
you
who
want
to
do
some
machine
learning
inside
of
the
enclave.
That
is
is
quite
interesting
to
see,
but
it's
a
fairly
it's
more
of
the
easy
stuff.
So
it's
not
exactly
a
deep
learning
experience
that
you
have
there,
but
rather
I
think
k
means
so.
A
Okay
means
classification.
Even
so
it's
not
very
sophisticated,
but
it's
a
translation
of
or
a
patched
version
of
rusty
machine.
I
think
then,
and
la
and
last
but
not
least,
we
are
going
to
look
at
the
unit
tests
because
you
know
as
a
as
good
engineers.
We
want
to
test
our
code
and
obviously
that
should
also
apply
to
stuff
that
is
running
in
the
enclave,
because,
obviously,
without
the
standard
library
we
don't
have
a
testing
framework,
so
there's
a
way
that
they
came
up
with.
That
is
quite
nice
to
run
tests
actually.
A
So
as
we
go
forward
a
little
bit
in
time,
so
I
did
this
not
too
long
ago.
So
you,
the
preferred
way
to
run
and
work
with
sgx
is
in
a
docker
container.
So
in
this
case
I
did
yeah
docker
run
mapped
the
current
volume
into
root
sgx
map
the
device
as
a
as
an
enclave
in
there
and
use
the
baidu
xl
xlab
sgx,
rust
ubuntu
container,
with
ubuntu
1804
with
the
the
newest
rust
sdk
also
supports
2004,
but
I
didn't
see
it
yet.
A
So
we
are
working
with
the
old
sort
of
yeah
the
old
sdk
in
there,
then
there's
something
that
is
called
the
aesm
service
which
manages
sort
of
the
enclave
access.
So
it
needs
to
run
in
the
background
and
the
docker
containers
don't
have
that
running
by
default
for
some
reason,
probably
because
you
can
also
map
in
a
socket
and
use
your
outside
right.
In
this
case,
I
could
use
the
outside
thing
as
well,
because
it's
it's
installed
on
the
azure
confidential
compute
vm
as
well.
A
So
if
we
go
into
the
and
to
our
cd
into
this
sgx
sample
code
thing-
and
we
do-
we
want
to
execute
the
the
hello
rust
or
look
in
the
hello
rust
thing.
We
have
to
run
a
make
file
and
we'll
look
at
that
in
a
second
and
then
you
know
it
downloads
everything
because
we
didn't
map
it
in
it
doesn't
have
a
rust
installed
by
default
either.
So
it
downloads
everything
and
then
eventually
in
that
make
file.
It
also
links
everything
together.
A
Ultimately,
so
it
creates
a
native
library
or
two
native
libraries
really
and
maps
it
all
together
with
like
links
together
with
generated
enclave,
proxies
and
then
outputs
the
enclave
configuration.
And
then
it
says
yeah,
it's
done
so
and
then
you
have
something
in
in
the
bin
folder
and
you
can
execute
that
and
then
yeah.
The
result
is
hopefully
something
successful.
A
A
And
so
we
see
that
this
is.
This
is
the
main
rs.
So
these
are
the
two
parts
we
have
the
app
part
here
and
we
have
the
enclave
part
here.
So
this
is
the
untrusted
part.
Is
you
know,
you're
regularly,
regular
rust
program
and
the
enclave
part?
Is
your
trusted
environment
here
and
there's
all
kinds
of
other
things
to
support
that?
A
So
this
is
the
the
make
file
that
we
called
earlier.
This
makefile,
you
know,
does
if
you
want
to,
if
you
enjoy
reading,
make
files.
That
is
a
this
is
definitely
a
good
read,
but
the
important
part
is
here
that
the
sgx
mode
is
here
set
to
hardware,
which
means
that
it
tries
to
build
it
with
with
the
device
that
is
called
dev
sgx,
slash
enclave,
which
is
the
newest
driver
that
you
can
do
previous
drivers
had
like
a
dev
is-gx
device
instead
yeah
so
yeah
this.
A
A
First
in
the
untrusted
part
it
it
uses
a
little
bit
of
an
older
coding
style,
which
is
which
is
or
older
a
little
bit
more
c
c,
like
coding
style
as
well,
and
any
any
of
the
trusted
functions
are
imported
using
an
extern
statement.
So
this
is
just
like,
as
if
you
would
interact
with
any
any
kind
of
c
library,
any
kind
of
native
code
and
yeah.
You
have.
A
A
B
There
is
a
kind
of
flickering
when
you
always
see
your
beautiful
car.
In
the
background,
I
think
it's
a
rolls-royce
what
we
should
see
it
wasn't
that
bad.
While
we
were
looking
at
this
at
the
slides,
but
now
when
looking
at
the
code,
it's
kind
of
disturbing,
can
we
try
to
stop
screen,
sharing
and
re-share
again
just
to
give
it
a
try.
A
A
A
A
Yeah,
yeah
and
I'll
try
not
to
move
my
mouse
so
the
main
function.
This
is
a
hello
world
example,
so
it's
pretty
simple
it.
It
creates
a
string
and
it
also
uses
the
string
like
the
string
as
a
pointer
if
you
have
ever
done
any
sort
of
native
code,
interaction
with
rust.
This
is
exactly
the
way
to
do
it.
This
is
you
have
an
unsafe
function.
You
have
an
unsafe
scope.
A
The
ras
compiler,
doesn't
can't
guarantee
any
memory
safety,
which
is
why
it's
unsafe
to
call
in
there
and
everybody
has
to
kind
of
work
out
the
how,
when
to
free
the
memory
yeah
on
their
own,
so
calling
across
this,
as
you
can
see,
is
fairly
easy.
If
you
have
ever
done
anything
any
c.
Interoperability-
this
is
basically
the
same.
A
So
then,
let's
look
at
the
enclave
code,
so
this
expectedly
this
will
have
to
be
linked
to
something.
So
this
uses
dynamic
linking-
and
in
that
case,
that
means
we
have
a
build
rs
file
and
that
build
rs
file
talks
about
that.
Rather
it
uses
the
the
linking
the
dynamic
linking
that
you
would
use
and
it
communicates
for
those
of
you
who
have
never
done
that
it
communicates
over
the
standard
standard
out,
which
is
quite
funny.
A
I
thought
this
was
like
such
a
simple
way
to
communicate
between
between
the
tools,
but
it
works
well,
obviously
so,
enclave
code,
the
enclave,
is
a
fairly
regular
library.
So
you
can
see
that
this
is
a
static
library
and
it's
a
no
scd
library,
so
they
use
that
they
use
the
sort
of
the
attributes.
To
do
that,
you
could,
I
think,
do
that
same
thing
in
the
cargo
tomml
and
there
you
also
have
to
do
the
extern
crate
declarations
as
well.
A
A
So
this
can
be
maybe
a
little
bit
confusing.
I'm
still
torn
about
this
practice.
If
that
is
a
good
practice
or
not,
but
essentially
what
that
gives.
You
is
a
similar
structure,
then
in
in
a
regular
standard
library
and
even
comes
with
their
own
types
like
strings
and
vectors
and
stuff
like
that,
even
re-exports
of
traits
like
the
the
write
and
read
trait,
which
is
quite
cool
and
yeah,
you
can
even
read
you
know,
files
and
stuff
like
that.
A
So
again,
as
as
with
regular
language
interop
with
native
code
is
the
no
mangle
attribute,
and
that
means
that
the
compiler
doesn't
change
the
name,
so
it
doesn't
do
name
mangling
in
order
to
preserve
so
preserve
the
name.
So
it
can
do
a
dynamic
lookup
of
the
function
and
the
same
thing
it
right.
It
has
to
do
an
extern
c,
so
it
also
allocates
sort
of
the
function
name
in
a
specific
part
of
the
library.
A
There's
again
sort
of
this
is
all
safe
code,
except
for
a
few
of
these
sort
of
the
stuff
that
comes
in
has
to
be
right.
All
the
parameters
then
have
to
be
again
added
to
a
memory
layout
and
potentially
cast
it,
which
is
something
that
a
rust
doesn't
really
do
in
a
safe
way
or
can
do
in
a
safe
way,
but
usually
from
pointer
to
a
different
type
of
pointer.
It
doesn't
really
like
to
do
in
a
safe
way.
A
Therefore,
there's
a
few
unsafe
things
that
you
always
have
to
do
when
working
with
these
with
these
yeah
incoming
types,
then
yeah
not
not
much,
not
very
special.
Here
we
can
even
use
the
the
vec
macro
and
all
this
is
a
no
std
environment,
and
it
looks
very
very
like
like
a
regular
rust
program
which
is
quite
cool
and
is
quite
yeah.
It's
impressive!
Actually
to
how
well
they
did
here,
I
think,
but
looking
at
the
cargo
towel
that
looks
a
little
bit
different.
A
A
Then
the
enclave
itself
can
be
configured
so
that
that's
a
config
there's
an
xml
config
file
that
goes
with
the
enclave
which
gives
it
sort
of
where
you
can
define
heap
size
stack,
size,
tcs,
num
and
tcs
policy
is
about
threading,
so
you
have
to
define
the
number
of
threads
beforehand
and
the
tcs
policy
there's
two
types
of
threads:
they're,
bounded
and
unbounded
threats,
and
currently
only
bounded
threats
are
supported.
So
then
you
actually
have
to
put
a
zero
there,
but
otherwise
it
just
panics.
A
So
that's
something
for
for,
if
you
want
to
dive
into
c
plus
plus-
and
I
bet
the
developer's
guide
has
something
to
say
about
that-
that's
yeah
that
that's
a
different
way
of
doing
it.
I
think
bounded
thread.
Threads-
are
sort
of
bounded
together
with
outside
so
untrusted
threats,
but
yeah
in
a
in
a
in
some
way
that
I
didn't
explore
too
deeply
yet
so
the
second.
The
second
thing
that
I
wanted
to
look
at
with.
B
A
You
have
a
lot
more,
a
lot
more
imported
functions
and
in
this
case,
after
the
initialization
of
the
enclave
there's
a
lot
of
code,
as
you
can
see
on
the
right,
it's
a
lot
of
code
there
and
that
is
essentially
atls
client
and
that
tls
client
is,
if
you
look
up
the
rust
tls
client
example.
It's
exactly
that
thing.
So
this
is
the
rust
dls
client
and
it
uses
a
meal
to
kind
of
work
on
the
stream
to
to
see
when
it
has
to
read
and
when
it
has
to
write.
A
A
Usually
it
uses
a
buffer
internally.
That
does
the
that
does
that
so,
first
it
reads
stuff
into
its
buffer
and
then
it
tries
to
decrypt
it
using
this
provided
certificate,
and
in
this
case
we
do
the
decrypting
and
the
reading
of
the
actual
data
inside
the
enclave.
So
every
read
tls
call
on
line
156
and
is
forwarded
into
the
enclave.
A
So
in
159
you
see
that
this
is
calling
into
the
enclave
to
read
a
buffer
and
once
that
results
in
something
well
just
it
hands
it
forward
into
the
current
buffer,
and
I
think
in
this
case
it
just
prints,
it
out,
understand
on
standard
out,
and
it
does
the
yeah
the
painting
here
here
it
does
the
printing
and
206
and
yeah.
That's
that's
sort
of
what
it
does
right.
A
It
just
prints
it
to
to
stand
it
out,
the
the
main
function
itself
again
in
it,
the
enclave
and
just
as
before
it
uses
the
disconnects
to
the
local
server.
So
the
to
the
server
part
here
does
all
the
sort
of
you
know
connecting
and
different
in
different
ways:
instantiates,
the
tls
client,
the
tls
client
in
turn,
goes
into
the
enclave
and
creates
the
tls
client
there.
So
that
this
case-
and
this
is
why
I
wanted
to
show
it
to
you-
is
the
enclave-
is
also
holding
a
state
internally.
A
B
B
A
A
So
once
that
is
created
in
a
new
client,
you
see
it
creates
a
a
box,
so
it
allocates
heap
memory
and
puts
that
heap
memory
puts
that
box
into
a
new
session
and
that
new
session
registers
itself
in
the
in
the
global
context,
using
a
specific
id
and
well
the
current,
the
current
enclave
id.
So
then
it
associates
it
has
one.
A
This
lazy,
lazy,
static,
global
memory,
sort
of
and
registers
the
pointer
with
the
the
and
associates
it
with
the
enclave
id
and
therefore
carries
over
in
between
different
calls.
It
carries
over
what's
what's
in
that
current
tls
client
and
that's
quite
quite
interesting.
It's
not
very
easy
to
read.
Let's
say
like
that,
but
it's
very
interesting
how
that
how
that
works?
A
I
see
it
as
a
session
id
for
the
read,
so
you
create
it
on
one
at
one
point
in
time
and
then
on
line
310,
you
call
read
after
some
time
you
use
the
session
id
and
use
it
on
to
fetch
your
session
pointer
and
cast
it
so
line.
3,
17
and
line
318
do
exactly
that,
so
they
fetch
the
session
out
of
that
global
registry
and
transmute.
A
A
positive
integer
like
the
number
of
bytes
it
read,
which
is
quite
typical
for
any
type
of
c
programming,
and
this
sample
code
in
general
is
very
much
c,
like
not
very
rust,
like
from
from
a
coding
style,
so
something
that
we
didn't
look
at
before.
So
we
define
all
of
these
external
functions
in
in
an
edl
file,
and
this
edl
file
looks
very
much
like
a
regular
interface
definition,
language
that
you've
seen
before.
A
Maybe
so,
it
imports
all
of
the
different
extension
or
rather
the
the
the
other
things
that
are
trusted
calls.
And
if
you
wanted
to
add
something
here
like
threading,
for
example,
this
would
have.
This
would
lead
to
another
import
statement
that
you
have
here
the
e-calls.
So
the
the
calls
into
the
enclave
are
part
of
the
trust
set
scope
and
if
you
had
oh
call
so
outside
or
back
outside,
like
a
callback
or
something
like
that,
that
you
would,
that
would
be
an
untrusted
scope.
A
A
A
A
So
in
this
case
this
is
when
I
executed
when
I
built
the
the
the
the
server
and
the
client
earlier,
we
can
run
it
again,
but
essentially
this
is
this
is
gonna,
be
output,
so
running
the
server
and
then
connecting
with
the
with
the
client
is
simple,
and,
as
you
can
see
this,
this
works,
I
think
we
should
yeah.
I
don't
think
we
have
to
run
this
particular
one,
because
we
can
move
on
to
the
last
code
and
arguably
the
most
important
unit
testing.
A
A
So
if
you
wanted
to
make
it
really
secure,
you
would
not
do
that.
You
would
probably
deliver
the
certificate
as
part
of
the
application
of
part
as
part
of
the
application.
What
that
means
is
that
you
have
a
that.
You
have
a
public
key
of
something
to
encrypt
the
communication
between
you
and
the
other,
the
other
party,
so
that
could
be
a
web
server
if
you
use,
for
example,
a
crypto
exchange.
If
you
wanted
a
cryptocurrency
exchange
that
you
want
to
call,
you
use
the
public
key.
A
Add
that
to
your
application,
so
you
don't
have
to
read
it
from
a
potentially
a
spoofed
file
right
and
encrypt
this
encrypt,
your
communication,
essentially
between
inside
the
enclave
and
this
exchange
api.
So
what
that
means
is
that
no
one
from
the
outside,
so
the
outside
only
has
the
socket
but
doesn't
have
the
encryption.
The
encryption
key,
so
the
encryption
will
sort
of
any
party
listening
on
that
socket
or
doing
a
memory
dump
will
not
know
what
you
are
actually
communicating
between
the
enclave
and
your
other
party,
your
trusted
party.
A
So
what
it
does
is
essentially
that
enclave
can
then
fetch
data
from
that
from
that
exchange,
for
example,
trading
data
do
something
with
it.
You
know,
apply
your
secret
or
not
secret
algorithm
and
the
you
know
do
some
make
trading
decisions
based
on
that,
and
you
can
only
make
really
trading
decisions
if
you're
absolutely
sure
that
the
other
thing
that
the
arab
party
or
the
data
you're
basing
those
decisions
on
is
really
the
data
you're
expecting
and
thinking
about,
and
while
this
is
a
finance
example,
I
think
there
are
other
examples
where
this
is.
A
This
is
interesting
too,
like
you
could
do
information
exchange
without
you
know,
without
processing
that
specifically
for
for
financial
trading,
but
you
could
make
decisions
based
on
data,
and
then
you
can
be
sure
that
this
data
is
only
read
by
well.
The
data
that's
been
sent
is
only
read
by
inside
the
enclave,
and
what
goes
out
of
the
enclave
is
maybe
only
the
decision
that
has
been
made
based
on
that
data,
so
that
would
be
one
one
fairly.
A
A
You
know
if
you
had
more
sensitive
parking
ticket
is
not
very
sensitive,
but
if
it
was
your
garage
door
opener
or
something
like
that,
you
would
have
want
to
have
that
encrypted
as
well.
So
there's
different
applications
for
that,
and
this
is
what
I'm
now
talking
about-
is
fairly
specifically
the
town
crier
architecture
paper.
So
if
you,
google,
that
you'll
find
the
tom
cry
architecture
as
a
thing.
A
All
right
so
unit
testing
as
good
engineers.
We
want
to
unit
test
our
stuff
most
of
the
time,
and
this
is
also
possible
to
do
it
within
the
enclave
so
again
same
structure,
you
have
an
app
part
and
you
have
an
enclave
part
and
the
app
part
has
the
app
part
has
again
a
main
function.
In
this
case,
it
doesn't
have
to
be
the
main
function
you
could
also
have.
A
So
what's
the
really
interesting
part,
therefore,
is
happening
in
the
enclave
and,
as
you
can
see,
they
have
built
a
bunch
of
modules
for
that
and
chained
it
all
together
in
the
lib
rs,
and
also
created
a
sgxt
unit,
test,
yeah
great
for
use
and
then
a
macro
to
kind
of
run.
All
of
these
tests
yeah,
because
it's
probably
more
convenient
and
yeah.
It's
a
ton
of
tests
and
the
reason
why
it's
also
important
for
this
sdk
is
it's.
A
It
shows
you
how
to
use
all
of
the
features
that
don't
have
sample
codes,
and
that
is,
I
think,
fairly
significant,
especially
if
you
wanted
to
build
threads,
because
threading
is
not
that
easy,
as
it
turns
out,
because
the
the
yeah
the
documentation
is
a
bit
scarce.
Let's
say
on
that,
so
this
this
looks
fairly
normal
right
thread,
spawn
nothing,
nothing
specific
on
that.
You
can
also
use
a
thread
builder
to
work
on
that,
but
what
the
difference
is
is
that
all
of
this
has
to
be
first
of
all
declared
in
in
the
edl.
A
So
working
on
the
threads
here
is
is
that
then
you
have
a
config
stuff
that
has
to
be
changed.
So
in
this
case
we
can
build
up
to
10
threads,
which
is
useful
for
unit
tests
in
general,
and
the
threading
policy
is
not
one
but
zero,
meaning
that
it
it
has
bounded
threads
and
it
uses
the
way
that
the
well,
the
only
way
that
the
sdks
recognizes
threats
and
other
things
are
similar
like
that
right.
A
A
A
So
you
have
you're
inside
just
sort
of
the
root
folder
of
your
project.
You
run
make
you
see
that
I
ran
make
before.
Therefore,
it's
not
a
lot
of
not
a
lot
of
compiling,
but
you
see
that
there's
you
know
there's
again
the
enclave
configuration
as
the
output
and
it
has
a
lot
more
memory
than
the
others,
which
is
also
interesting.
I've
not
run
into
an
out
of
memory
problem
yet,
but
it
seemed
to
have.
A
I
had
that
and
then
you
have
to
really
change
your
working
directory
into
the
bin
folder
and
run
the
app
if
you're
not
doing.
If
you
don't
do
that,
then
yeah,
then
you
get
a
weird
exception,
which
is
yeah
costs
a
little
bit
of
headache
and,
as
you
can
see,
this
is
a
fairly
similar
to
what
we
would
have
in
regular
rust
unit
testing
and
there's.
The
few
exceptions
that
are
shown
here
also,
as
in
regular
rust
unit
testing,
shows
you
the
panics
and
accepts
them.
A
If
the
test
says
it
should
panic
and
yeah,
as
you
can
see,
199
unit
tests
in
there
and
all
of
them
passed
and
yeah,
it's
quite
interesting.
I
think
that
it
works
like
that
and
again
yeah.
You
can
create
basically
a
regular
tested
application
inside
the
enclave
call
and
and
combine
it
with
your
regular
tests
from
your
untrusted
code
and
therefore
yeah
follow
good
engineering
practice.
I
guess
and
still
have
trusted
and
untrusted.
A
Division
so,
and
that's
it
so
you
can,
I
will
send
out
the
link
for
this.
If
you
don't,
if
you
didn't
type
it
already
in
your
into
your
browser,
I
can
send
you
this
presentation,
so
these
are
the
three
examples
and
yeah.
So
thanks
for
listening
to
me
rant-
and
I
think
if
this
is
the
last
chance
for
questions
maybe
but
yeah,
otherwise
I
blog
sometimes
on
my
blog
there's,
also
where
you
can
find
my
books
if
you're
interested
and
yeah
other
than
that.
Thank
you.
B
Raj,
this
is
the
first
chance
for
me
to
say.
Thank
you.
Thank
you
for
this
awesome
talk.
It
was
really
interesting
and
it
made
me
think
a
lot.
I
personally
do
a
lot
of
work
in
the
cloud
computing
space.
I
have
been
doing
that
for
10
years
now,
and
I
think
this
might
be
really
a
game
changer
for
some
applications,
because
especially
here
in
europe,
we
have
a
lot
of
discussion
going
on
whether
we
should
trust
u.s
companies,
running
clouds
and
so
on.
B
And
how
can
we
do
critical
workload
in
cloud
data
centers,
which
are
obviously
useful,
but
we
don't
trust
100,
maybe
only
95
percent,
and
I
guess
this
is
really
a
a
very
interesting
option
that,
as
I
said,
might
be
a
big
game
changer.
What
would
be
interesting
for
me
and
I
encourage
everybody
to
ask
questions
over
this
court.
A
Site,
well,
it's
not
in
production
yet,
but
the
company
I'm
working
with
as
a
as
a
freelance
consulting
is
issues
is
looking
to
launch
end
of
december
and
in
this
case
it's
yeah.
It's
a
it's
a
crypto
finance
thing,
and
this
is
this-
is
fairly
yeah.
It's
fairly
pretty
much
what
I
talked
about
as
a
real
world
example,
it's
a
little
bit
more
sophisticated
than
that.
A
B
B
A
B
B
B
Yeah
cause,
if
you
can,
and
if
you
like
you
can
join
us
on
discord.
Maybe
you
can
hang
around
for
a
little
bit
longer,
I'm
not
sure
if
you
are
already
on
our
discord
server.
If
you
are
not,
you
are
very
much
invited
with
that.
People
can
maybe
ask
some
questions
or
they
can
use
your
url
that
you
just
shared
here
to
get
maybe
in
contact
you
with
you
via
twitter,
or
something
like
this.
That
is
that,
okay.