►
From YouTube: Lessons from the Nomad Hack
Description
Visit the https://archive.devcon.org/ to gain access to the entire library of Devcon talks with the ease of filtering, playlists, personalized suggestions, decentralized access on Swarm, IPFS and more.
https://archive.devcon.org/archive/watch/6/lessons-from-the-nomad-hack/
The Nomad Bridge suffered an incident in early August, resulting in about $190M in cryptocurrencies lost. We will see how the Nomad Bridge was able to get hacked and how it relates to the Nomad Protocol. Finally, we will share learnings and insights we got from this incident, actionable tips that all protocols should take into serious consideration in order to reduce the probability of a potential hack.
Speaker(s): Odysseas
Skill level: Intermediate
Track: Developer Infrastructure
Keywords: Solidity,Foundry,cross-chain applications (xapps)
Follow us: https://twitter.com/efdevcon, https://twitter.com/ethereum
Learn more about devcon: https://www.devcon.org/
Learn more about ethereum: https://ethereum.org/
Devcon is the Ethereum conference for developers, researchers, thinkers, and makers.
Devcon 6 was held in Bogotá, Colombia on Oct 11 - 14, 2022.
Devcon is organized and presented by the Ethereum Foundation, with the support of our sponsors. To find out more, please visit https://ethereum.foundation/
A
A
I'm
super
happy
to
be
here
or
not
so
happy.
I
would
prefer
to
talk
about
something
else,
but
you
know
we
do
what
we
can
right.
So
first
we
have
to
start
with
the
basics
I'm
not
here
on
behalf
of
illusory,
which
is
the
company
behind
nomad.
So
the
views
Express
are
my
own
and
do
not
reflect
those
of
the
company.
A
As
it's
an
active
investigation
right
now,
an
active
incident,
we
will
be
not
doing
any
q
a.
Unfortunately,
my
name
is
Odysseus
I'm,
a
protocol
engineer
in
Nomad
I've
worked
in
web3
as
a
consultant
and
also
been
working
as
a
devops
in
iot.
So
today
we'll
be
talking
about
Nomad.
What
is
Nomad,
how
the
protocol
works?
We
will
need
that
to
be
able
to
talk
about
bridges,
how
they
work
on
the
incident.
And,
finally,
what
are
the
learnings?
We
have?
A
What
did
we
learn
from
losing
about
having
a
hug
has
resulted
in
a
190
million
dollars
in
tokens
being
evaporated?
Nomad
is
not
a
bridge.
Nomad
has
a
bridge
right,
but
if
no
one
is
not
a
bridge
and
has
a
bridge,
that's
namad
is
an
optimistic
protocol.
First
of
all,
which
means
that
it
has
an
optimistic
security
model.
A
A
We
don't
Define
how
your
application
will
react
to
some
event.
Basically,
The
Nomad
protocol
will
just
send
arbitrary
bytes
from
one
domain
to
another.
So
it's
you,
the
developer,
to
interpret
those
bytes.
So
Nomad
is
an
optimistic
protocol
for
interpretability
that
supports
arbitrary
messages
between
domains.
A
How
Nomad
works.
The
first
thing
you
have
to
know
about
Nomad
and
probably
the
last:
it's
that
it's
super
simple
on
the
sending
chain,
all
the
messages
that
are
being
sent,
they're
added
to
a
metal
tree
right
so
and
why
we
do.
That
is
because
it's
very
easy,
with
a
medical
tree
to
prove
whether
a
methods
belongs
to
the
tree
or
not.
A
The
information
of
inclusion
in
theory
and
in
practice
is
included,
is
compressed
into
the
root,
so
the
protocol,
only
it
only
has
to
do-
is
to
send
that
route
from
the
sending
chain
the
receiving
chain.
If
we
do
that
securely,
then
anyone
can
go
to
the
receiving
chain
and
prove
that
the
methods
indeed
belongs
to
the
tree.
That
has
that
root.
So
all
that
the
protocol
does
really
is
that's
passing
this
route
from
the
sending
name
domain
to
the
receiving
domain
domain
is
a
chain
right.
Let's
see
the
life
cycle
of
a
message
denomad.
A
A
Then
we
must
wait
for
them
to
be
some
optimistic
window
to
pass
afterwards.
We
can
go
to
replica
to
the
receiving
domain
and
say
hey.
Here's.
The
other
proof
of
inclusion
here
is
the
message:
I
want
to
prove
that
this
message
was
indeed
sent
and
after
we
prove
a
message,
we
can
process
it
and
we
will
process
a
message.
Basically,
the
replica
contract
will
take
the
message:
metadata,
call
the
contract
destination
contract
and
pass
the
message.
Payload
super
simple.
A
A
Basically,
you
go
to
the
sending
chain
right,
let's
say:
ethereum
you
go
to
the
contract
and
say:
hey
bridge
I
want
to
send
my
native
tokens
with,
for
example,
it's
a
native
token
to
ethereum.
It
has
intrinsic
value
and
I
want
to
send
it
to
Paul
to
evmos
right
then
the
bridge
will
hold
that
width
and
it
will
send
a
message
to
the
receiving
chain
to
The,
Nomad
Bridge
receiving
end
and
say:
hey,
you
should
mint.
You
should
create
a
new
mud
with
a
representation
Dragon
which
doesn't
have
any
any
value
in
itself.
A
The
value
is
derived
from
the
fact
that
we
can
do
the
opposite,
that
the
user
that
holds
the
mod
with
can
go
to
the
bridge
and
say
Hey
I
want
to
burn
that
token
and
I
want
to
transfer
my
mod
with
back
into
ethereum.
So
the
bridge
will
send
a
message
back
and
say:
hey
unlock
and
your
wave
hug
is
when
the
all
this
locked
collateral
in
the
bridge
is
stolen
right.
A
So
now
all
these
representations
that
are
flying
around
they're
essentially
worthless
because
they
can't
be
redeemed
for
the
original
asset,
for
the
asset
has
intrinsic
value
and
I.
Think
that's
why
we
have
we've
seen
so
many
hearts
and
bridges,
not
only
because
they
are
indeed
complex
systems
and
they
are,
but
because
also
they
have
so
much
collateral
locked
inside
them,
they're
very
juicy
targets.
They
make
good
targets
for
hikers
to
pry
and
test
for
the
vulnerabilities
foreign.
A
Let's
talk
about
the
incident.
What
how
was
the
number
of
the
bridge
possible
to
be
hacked?
We'll
talk
about
two
mappings
in
the
replica
contract?
Two
pumpings
was
all
it
took.
The
first
mapping
connects
a
route
to
the
timestamp
that
says
that,
after
that
time
stop
that
route
is
indeed
valid.
You
can
start
proving
messages
against
the
root
the
root
of
the
medical
tree
right,
so
a
new
route
comes
and
the
new
timestamp
is
generated.
A
A
A
A
So
what
users
did
they
forged
messages
that
were
meant
to
the
bridge
that
told
the
bridge,
hay
and
all
that
collateral
and
see
any
arbitrary
methods
that
has
not
already
been
proven
is
proven
under
the
root
zero
it
could
prove
and
process
whatever
they
wanted
and
that's
right
there,
190
million
bug.
So
why
did
it
come
up
now
right,
The
Nomad
protocol
has
been
active
for
months.
A
We
had
an
upgrade
and
during
the
upgrade
we
changed
the
semantics
of
the
second
mapping.
So
we
used
to
store
an
enum
here
like
numbers
numbers.
So
if
the
number
is
one
it's
proven,
if
number
is
2
is
processed,
so
we
didn't
connect
messages
to
the
roots
under
the
under
which
they
are
proven
right.
So,
even
if
the
route
was
active,
we
you
know
through
the
authentication
flow.
A
We
made
sure
that
we
didn't
authenticate
that,
but
we
changed
the
semantics,
and
that
is
why
the
bug
was
so
hard
to
find
our
testing
didn't,
find
it.
Our
Auditors
didn't
find
it
because
it
needed
the
old
state
with
a
new
code.
It's
an
old
state,
with
old
code,
secure
new
state
with
new
code,
secure
all
state
with
new
code,
not
secure
Nomad.
Now
the
protocol
is
closed,
will
restart
the
bridge.
That's
the
hard
part.
How
do
we
restart
an
uncollateralized
Bridge,
we'll
be
sharing
more
information
soon?
A
A
A
We'll
talk
about
not
improvising
that
and
overcome,
but
we'll
talk
about
test,
observe,
engage
and
communicate.
You
can
think
about
as
different
layers
in
the
defenses
of
a
castle
right.
Hopefully,
these
layers
of
defense
will
stop
the
attackers
from
reaching
the
Citadel,
the
king
or
queen.
It's
like
the
treats
his
analogy:
security
I'm
sure
most
of
your,
your
researchers
will
know
about
that
security
analogy,
but
I
think
castles
are
way
cooler
than
cheese.
That's
why
I
prefer
to
do
castles?
A
Yes,
the
bread
and
butter
of
every
developer
right
there
are,
although
there
weren't
any
best
practices.
I
think
the
industry
is
now
slowly
aligning
on
these
on
some.
You
know
best
practice
on
this,
so
we're
having
the
unit
tests,
property-based
tests,
integration
tests,
forking
tests
and
Environ
tests
and
I
want
to
go
a
quick
rundown
through
them.
First
of
all,
concrete
tests.
Super
simple
I
want
to
make
sure
that
the
function,
if
I
give
it
five
I
will
get
25.
We
also
name
it
concrete
function.
Concord
test,
property-based
tests
are
more
advanced.
A
They
force
you
to
think
about
the
properties
of
your
code,
so
basically
to
verify
that
this
function
will
give
the
input
multiplied
by
5.
Always
then
we
have
the
integration
test
where
we
want
to
test
bigger
picture
features.
User
flows
working
test
which
is
like
a
web
free
specialty,
all
the
other
tests
you
can
find
them
in
other
paradigms.
A
forking
test.
A
Basically
could
be
an
integration
test
or
a
unit
test,
but
we
test
against
the
on-chain
state,
and
this
is
very
important
because,
as
you
saw,
a
bug
can
Surface
itself
only
using
the
Unchained
state
and
finally
warranties.
My
personal
favorite
environments
are
these
equations
phrases
that
should
always
hold
for
your
protocol
right.
If
that
phrase
doesn't
hold
at
some
point,
the
protocol
should
be
posted.
The
protocol
has
broken
in
some
way.
So
this
is
a
big
project.
You'll.
Do
it
in
two
phases?
A
First
phase
you
will
Define
the
invariance,
so
it's
a
very
theoretical
phase,
not
easy.
Definitely,
and
then
it's
testing
the
variance
using
any
tools.
There
are
a
lot
of
tools
out
there,
for
example,
in
Nomad
the
environment
that
broke
was
that
all
messages
that
are
processed
right
received
must
have
been
sent.
A
A
In
my
view,
you
should
prioritize
unit
test,
obviously
a
property
based
test
on
forking
tests.
This
should
be
your
primary
focus
with
tools
like
Foundry
boundary.
It's
very
I
think
it's
easier
than
it
used
to
be.
Of
course
you
should
always
audit.
You
know,
use
a
do
an
audit,
although
it's
not
a
silver
bullet,
so
don't
just
do
audits
and,
of
course,
always
take.
The
source
layout
always
observe
the
second
pillar.
A
Now
we
have
tested
alerting
if
you
receive
a
hero
passage,
and
you
aren't
already
up
it's
too
late,
like
your
alerting
has
failed.
You
shouldn't
wait
from
a
certain
Twitter
account
to
tell
you
that
there's
a
problem
with
your
protocol.
This
is
a
solved
problem
in
web
2.
Web
3
would
like
to
invent
things
again
and
again,
but
it's
a
salt
problem
in
wealth.
Two
so
go
and
read
the
Google
series
handbook
you'll,
get
a
ton
of
input,
also
talk
with
your
devops
engineers.
A
If
they
have
worked
in
web
2
before
they
will
have
a
lot
of
insight,
for
you
usually
start
with
an
object,
you
know
the
business
objective
and
then
Define
actionable
alerts
actionable,
that's
a
keyword
actionable.
That
means
that,
if
an
alert
a
is
activated,
then
you
should
do
B.
It
should
be
a
very
simple
if
that,
if
then,
you
know
close,
you
should
have
a
playbook
for
every
alert.
So
if
alert
a
happens,
you
should
do
that
and
that's
the
way
you
should
do
it
and
here's
the
script.
You
should
run
super
simple.
A
A
nice
mental
model
for
Alert
in
web
free
I
think
is
heuristics
and
environment-based
alerts.
Characteristics
are
rules.
They
require
human
intervention
to
make
to
understand
whether
that's
a
false,
positive
or
not
are
environment-based
alerts
where
you
have
enough
chain
agent
running
and
continues
taking
the
variance
of
the
protocol
more
complex,
but
can
be
automated
because
environments
shouldn't
produce
false
positive,
like
if
the
environment
alert
is
on.
That
means
that
either
you
didn't
Define
the
environment
properly
or
be
protocol
is
broken.
Another
way,
probably
it's
a
good
thing
to
pause.
A
The
protocol
now
engage
testing
has
failed,
alerting,
maybe
so
now
we're
in
the
engaging
we're
in
the
first
minutes
of
the
of
the
incident.
What
do
we
do
apart?
Our
hello
who's
told
us
that
would
not
rise
to
the
level
of
our
expectations.
We
fall
to
the
lever
for
training,
so
if
you
don't
have
don't
have
an
incident
Playbook,
if
you
haven't
gone
through
that,
you
will
not
be
able
to.
You
know,
act
appropriately
and
you
will
get
wrecked,
even
if
your
alerting
was
good.
A
So
a
good
Incident
Management
means
explicit
ownership.
Very
specific
persons
should
have
very
specific
ownership
of
the
management
of
the
incident
outcomes.
Every
person
should
know
what
should
be
the
outcome
of
their
work
during
an
incident.
Game
Day
game
day
game
day.
Do
that
again
and
again
go
through
simulations.
The
entire
organization
should
create
game
days
for
this
incident
because
they
will
happen,
they
will
happen
and
you
shouldn't
be.
You
know
during
the
incident
you
shouldn't
read
the
incident
playbook
for
the
first
time.
A
Yearn
internally
has
a
very
nice
blog
post
about
it.
I
highly
suggest
you
look
at
it
and
you
adapt
it
to
your
organization
within
an
engaging
proper
in
proper
time.
We
lost
money
right.
So
it's
now
time
to
face
the
music.
What
do
we
do?
I'm
sure
everyone
would
like
yeah.
Let's
talk
to
the
users,
you
know
we
have
to
be
transparent.
We
have
to
tell
them
what
happened.
We
have
to
be
no
tell
them
before
the
region
wrecked.
A
A
A
A
A
We
do
we
talk
with
our
partners,
ideally
through
more
privileged
communication
group
like
telegram,
maybe
we
can
share
it
more
than
we
share
with
the
public
because
of
ndas
and
all
that,
because,
as
you
are
losing
money
they
are
losing
as
well,
then
you
should
talk
with
a
chain
analytics
firm.
That
is
very
important.
A
I
will
tell
you
why,
because
apparently
people
they
suddenly
have
a
change
of
heart
when
legal
enforcement
agencies
are
zeroing
in
on
your
the
real
identities
right.
Suddenly
they
just
want
to
return
their
funds
back,
and
the
only
reason
and
the
only
way
for
to
recover
assets
is
using
a
chain
analytics
firm
as
we
go
on
and
analyze
all
these
transactions
and
find
correlations,
and
they
would
be
able
to
point
the
law
enforcement
agencies
to
centralizing
changes,
so
they
can
freeze
funds
and
requests
of
data
personal
data.