►
From YouTube: Notary: State Of Development - Justin Cormack, Docker
Description
Don’t miss out! Join us at our upcoming event: KubeCon + CloudNativeCon Europe in Amsterdam, The Netherlands from April 17-21, 2023. Learn more at https://kubecon.io The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects.
Notary: State Of Development - Justin Cormack, Docker
Speakers: Justin Cormack
This talk gives an overview of the status of the Notary project, and the Notary v2 work, and the context in the broader ecosystem. Supply chain security is becoming increasingly critical and its importance has been recognised, but the ecosystem of tools around this is confusing. So this talk will cover the context of the key ideas, including the TUF and in-toto projects and how they relate to the security outcomes people want to achieve.
A
I'm
Justin
comac
I'm,
the
CTO
Docker
I'm,
a
cncf
technical
oversight
committee
and
maintainer
of
Nature
and
I'm
David
tesser.
He
wasn't
on
the
bill,
but
we
we
always
like
to
do
our
presentations
jointly
and
usually
I've
done
them
with
Steve
Alaska.
But
it's
good
to
have
someone
else
for
a
change.
Yeah.
B
A
A
In
particular,
it
was
a
sidecar,
that's
out
on
the
side
of
a
registry
that
meant
first
of
all,
many
Registries
didn't
have
support
for
notary
at
all,
because
someone
had
to
be
run
on
the
side.
It
wasn't
a
native
part
of
the
registry
protocol
and
it
was
kind
of
there
were
other
related
problems.
With
that
there's
a
talk
I
did
back
in
2019
in
where
are
they
did?
A
A
You
know
kind
of
larger
scope,
route
Keys
than
that,
but
kind
of
which
is
a
really
great
model,
but
we
did
find
it
hard
for
people
to
adopt
because
they're
not
actually
used
to
that
kind
of
model
and
didn't
have
very
many
tools
for
it,
which
I
think
is
kind
of
a
problem.
One
of
the
one
of
the
issues
we
had.
A
A
So
we've
got
this
Focus,
particularly
on
pki
I
mean
if
you
look
at
X500
and
it
was
originally
designed
as
a
kind
of
framework
for
hierarchy
of
keys
for
everything
and
everyone,
including
individuals,
but
it
never
worked
and
we're
kind
of
left
with
the
organizational
identity
bits,
the
sort
of
s
and
https
piece
as
the
sort
of
dominant
kind
of
working
working
kind
of
Key,
Management
infrastructure,
that's
kind
of
around
a
bunch
of
principles.
We
had
around
key
management
in
general.
A
A
You
know
without
actually
exposing
the
private
key
and
then
so.
We
built
a
plug-in
model
around
that
so
that
we,
you
know
you
can
well
with
demo
as
your
key
Vault,
but
you
can
use
any
kind
of
Hardware
Key
using
the
kind
of
plug-in
model
that
we
built
to
show
you
that
in
the
demo,
oh
and
for
the
signing
formats,
we
have
we
eventually
after
some
many
iterations
settle
on
kose
again
on
on
those
review,
one
we
used
canonical
Jason
for
signing.
A
A
So
there's
all
sorts
of
issues
we
had
cozy
is
a
ITF
standard
to
improve
Jason's
owning
it
effectively
is
not
it's
not
Jason
that
supports
binary,
serialization
directly.
You
don't
have
to
you,
know,
wrap
everything
and-
and
you
know,
a
rap
binary
data
at
all
and
we've
been
using
the
go
Kozy
Library,
which
has
we've,
had
two
independent
Security
reviews
from
trail
of
bits
and
NCC
on
that,
and
we're
very
you
know
kind
of
happy
with
this.
A
As
a
as
a
foundational
standard
infrastructure
for
the
actual
key
formats,
we
spend
a
lot
of
time
working
with
you
know
we
wanted
to
put
things
natively
in
the
registry,
and
that
means
the
things
we
want
to
put
in
registry
of
signatures,
also
things
like
s-bombs
and
and
other
pieces,
so
the
oras
project
has
kind
of
been
around
since
2018
about
like
let's
put
more
stuff
in
registers.
It's
not
just
container
images.
A
What's
really
happened
now
is
that
we've
managed
to
you
know,
as
you
know,
as
we've
got
real
use
cases
coming
from
signing
and
so
on,
we've
actually
going
to
get
this
converged
into
an
officially
accepted
oci
1.1
standards.
That's
coming
out
soon,
so
this
is
actually
now
official,
another
kind
of
side
project
which
is
really
great
and
it's
seeing
wider
implementation
for
a
long
time.
A
People
complain
that
Docker
Hub
did
not
have
support
and
I'm
happy
to
announce,
sneak
preview
announcement,
we're
launching
this
on
Monday,
so
there
will
be
full
support
for
artifacts
on
Docker,
Hub
and
I.
Think
you
know
this
is
you
know
now
a
kind
of
becoming
a
mature
standard
and
officially
Upstream
in
ACI,
which
is
great
reference
types
for
the
other
part
of
this
work
that
we
ended
up
doing.
We
had
a
lot
of
requests
that
people
wanted
to
add
signatures
to
things
rather
without
actually
modifying
the
object
and
they
wanted.
A
Basically,
you
know,
be
able
to
add
signatures
address
bombs
out
it
basically
references
without
modifying
underlying
objects,
because
that's
the
kind
of
workflows
that
people
had.
So
we
spent
a
lot
of
time
working
on
this.
You
know
again
I
outside
the
93
project,
because
it's
a
general
oci
thing-
and
this
is
also
finally
being
standardized
in
oci
1.1
as
well
and
again,
we
at
the
moment
there's
support
on
Azure
ACR.
A
We
will
be
working
on
spot
on
Docker
Hub,
as
just
as
soon
as
we've
shipped
artifacts,
we'll
be
working
starting
work
on
that.
So
again,
as
it's
now
going
to
officially
part
of
the
oci
spec,
we're
expecting
to
see
much
more
use
of
it.
I
think
Amazon
has
support
as
well
yeah.
It's
still
things
right
where
I
say
yeah
Amazon's,
like
announced
some
things
that
they
are
they're
interested
in
doing
using
it
as
well.
A
B
Yeah
well
yeah.
Just
to
reiterate
what
Justin
was
has
been
talking
about
here
is
that
the
notary
project
has
really
taken
the
approach
to
build
carefully
upon
a
number
of
security
standards.
Right
and
and
notation
is
the
the
V2
Tool
that
I'm
going
to
show
you,
but
that
is
one
tool
of
as
you'll
see
different
tools
here
that
help
with
the
overall
secure
supply
chain
security.
B
B
C
B
It's
actually
pulling
up
to
the
Azure
key
Vault
to
create
the
private
key,
and
then
we
now
have
this
key
idea
signed.
So
this
key
that
we
created
is
uses
the
code
signing
certificate,
which
is
what
this
EKU
is.
But
you
could
imagine
in
an
organization
you
would
have
probably
a
subca
a
root
CA
to
you
know.
So,
if
something
were
to
happen
you
could
you
could
revoke
only
the
the
minimal
amount
of
damage.
So
with
that
we
created
the
key
now,
let's
add
that
key
to
to
be
able
to
be
utilized
by
notation.
B
And
you'll
see
that
our
key
is
being
stored
in
key
Vault
and
we're
going
to
utilize
that
to
do
some
signing.
But
first
you
know
it's
important
to
call
out
that
you
know
right
now.
The
the
local
Docker
instance
doesn't
have
the
oci
1.1
support
for
artifacts
and
referral
types
that
will
eventually
change.
So
for
now,
what
we're
going
to
do
is
we're
going
to
run
this
container
registry
locally
so
that
we
can
push
to
it.
B
And
so
now,
if
I
were
to
take
a
look,
oras
is
a
tool
that
allows
you
to
discover
those
artifacts
that
have
the
oci
enabled
registry.
So
when
I,
when
I
check
a
look
at
this
right
now,
there's
no
artifacts
attached
to
that.
To
that
image
that
I
just
created,
however,
what
I
can
do
is
I
can
use
my
key,
that's
up
in
key
Vault
to
sign
the
local
image
using
notation
when
I
sign
this
it's
going
to
come
back
with
a
with
a
Shaw.
B
It's
it's,
the
the
private
key
is
stored
remotely
and
so
I
have
no
access
to
it.
There
and
I've
now
I've
now
signed
that
local
image.
So
when
I
do
that
same
step
again,
I
can
see
here
that
the
local
image
has
a
signature
attached.
That
has
a
Shaw
a
unique
Shaw.
So
that
enables
me
to
do
a
verification
when
I
try
to
verify
you're
going
to
see
that
this
does
not
work
well.
Why
is
that?
B
And
that's
because
we
haven't
decided
by
default,
we
don't
trust
any
any
kind
of
certificates,
so
we
have
to
explicitly
add
that
to
our
configuration.
So
if
I
do
a
notation,
cert
LS
that
says
which
search
in
my
store
am
I,
trusting
and
right
now,
there's
none.
So
that
makes
sense
why
I
don't
trustify
signed
it,
but
I,
don't
trust
it.
Yet
I
could
pull
down
that
key.
That
I
used
the
public
key.
B
That
I
used
to
just
sign
that,
but
what
I
think
is
a
little
more
interesting
is
public
content
right,
so
you
know,
I
could
verify
my
local
image,
but
what,
if
I
had
an
image?
That's
just
I,
don't
I,
don't
know
it
could
be
on
Docker
Hub
could
be
somebody
else's
registry.
How
do
I
know
if
that
thing
is
what
it
was
supposed
to
be
when
it
was
created,
and
so
for
that
we
have
this
external
image.
This
web
networks,
Azure
ACR
GitHub
net,
monitor
image.
That
is,
that
I
that
I,
don't
necessarily
trust.
B
Yet
so,
when
I
list
that,
though
it's
got
a
whole
bunch
of
different
artifacts
attached
to
it.
As
you
can
see
here,
it's
got
a
vulnerability
scan.
It
has
an
attached
s-bomb
and
the
image
itself
and
all
three
of
all
three
of
those
things
are
signed.
So
how
do
I
know
if
I
can
trust
this
or
not
well
with
notation?
What
I
would
need
to
do
is
just
get
the
public
certificate.
Now
we
are
looking
into
ways
of
how
we
might
be
able
to.
B
You
know
make
this
a
better
experience
than
you
know:
curling
a
assert
from
from
GitHub,
but
for
now
this
this
does
work.
It
is
indeed
public.
So
if
I
add
this
public
cert
to
my
notation
trust,
store
and
I
do
a
notation,
cert
LS,
you
can
see
that
I
now
trust
that
cert.
So
what
I
can
do
now
is
I
can
verify
that
image
that
I
had
up
online
or
that's
that's
up
there
so
before
I
decide,
I
want
to
use
it
locally
or
in
any
other
place
or
pull
it
down.
B
The
other
nice
thing
that
you
can
do
is
you
know.
We
noticed
there
were
some
artifacts
attached
to
it,
so
one
of
the
things
I
might
do
is
you
know,
first
verify,
let's
say
the
s-bomb,
because
maybe
you
maybe
somebody
hacked
in
and
they
they
modified
the
the
software
Bill
materials
to
say
there
wasn't
vulnerabilities
or
something
in
it.
B
I
verified
that
that's
there,
so
that
seems
to
be
correct
and
I
can
actually
pull
that
software
build
materials
down
from
the
from
the
actual
Public
Image
and
when
I
look
at
that
I
now
have
the
s-bomb
there
right
pulled
from
the
the
public
registry
and
for
me
to
inspect
I
obviously
could
run
different
tools
on
it
to
see
if
there's
vulnerabilities
or
other
things
before
I
decide.
I
may
or
may
not
want
to
trust
that,
okay.
B
Okay,
so
this
is
a
real
scenario
here
that
does
happen.
What,
if
you
have
an
identity,
stolen
right?
Somebody
hacks
your
credentials,
or
it
may
even
be
that
somebody
creates
what
seems
to
be
a
real
account,
but
it's
fake
and
they
get
a
certificate.
It
could
be.
A
short-lived
certificate
could
be
ephemeral
could
be
keyless
whatever
you
want
to
call
it,
but
some
way
they've
obtained
an
identity
that
allows
them
to
valid
validly,
quote
unquote
or
get
or
use
a
certificate.
B
C
B
B
It's
a
fancy
way
to
think
of
it's
a
it's
a
location,
a
file
system
of
where
all
the
certificates,
just
like
the
one
I,
had
the
public
certificates
that
you
trust,
but
the
real
power
comes
in
to
with
trust
policy
trust
policy.
We
just
give
you
a
little
teeny
snippet
of
an
idea
of
what
you
could
do
here,
but
really
what
you
could
do
is
revoke.
Let's
say
that
that
compromised
identity
right
you
know
where,
let's
say
the
ca
or
subca
it's
coming
from
you.
Could
you
can
revoke
that
anything?
B
B
That's
signed
validly
there,
but
you
just
want
to
say
maybe
certain
things
out
there
that
you
want
to
not
trust,
and
so
there's
a
lot
of
power
in
this
and
customization
to
be
able
to
to
handle
these
kind
of
situations
that
may
come
up
and
and
furthermore,
at
least
in
the
specification
right
now,
we
do
support
oscp
and
crl
lists.
So
if
you,
if
you
want
to
go
to
that
level
of
extent,
you
can
go
there
to
to
query
for
revocation
lists.
B
Another
point
that
is
really
also
important
to
point
out
is
that
you
know
there's
there's
criticisms
out
there
on
on.
You
know
this.
This
revocation
thing
doesn't
scale
well.
I
would
I
would
argue
that
that
that
definitely
applies
for
the
the
https
right,
the
the
World
Wide
Web,
where
there's
just
an
insane
amount
of
sites
that
you
have
no
idea
like
like
what
they
are
and
there's
just
overwhelming
right.
B
But
when
it
comes
to
an
organizational
Enterprise
right,
you
should
have
a
much
smaller
list
of
entities
that
you
are
deciding
that
you
want
to
trust
even
for
Content
that
you
decide
to
pull
in
from
outside
sources.
You're
likely
going
to
resign
that
with
your
own
certificate
and
therefore
you
have
a
much
smaller
radius
and
it
becomes
much
more
manageable.
B
The
next,
the
next
thing,
though,
is
okay,
well,
so
great,
if
I
trust
it
or
not.
How
do
I
actually
enforce
this
stuff?
That
I
trust
right,
like
I,
got
the
thumbs
up
you're
down
on
the
thing,
but
how
do
I
make
sure
this
actually
happens
right
and
there's
two
places?
There's
two
really
I
would
say
key
places
that
you
need
to
think
about
enforcing
this,
and
that
is
likely
in
your
build
pipeline.
So
before
you
go
and
deploy,
let's
say
a
container
image.
B
You
want
to
verify
that,
since
it
was
created,
nothing
has
changed
and
it's
and
it's
reliable
right.
So
at
that
point
you
might
want
to
verify
the
image
to
make
sure
that
it
does
not.
You
know,
cause
any
extra
Cycles
on
the
on
the
on
the
cluster
once
it
goes
to
the
cluster
you
can
yet
validate
again
and
then
have
that
enforce
that
standard,
so
that
you
know
those
policies
that
you
decide.
You
want
to
apply
on
the
cluster
enforce
that
you
only
are
going
to
run
signed
content.
B
The
tool
that
we
use
in
this
particular
case
that
I'm
going
to
show
you
with
a
demo
is,
is
a
tool
open
source
tool
called
ratify
and
ratify
enables
you
to
to
do
that
enforcement
as
a
binary
which
you
could
put
into
a
pipeline
or
run
offline.
Technically,
if
you
wanted,
and
as
a
admission
controller
working
with
gatekeeper,
is
it's
an
actual
external
data
provider
for
gatekeeper,
and
then
it
runs
they're
working
with
gatekeeper
to
to
enforce
only
those
policies
that
you
desire.
B
The
first
thing
I'm
going
to
do
is
show
you
this
in
a
pipeline,
so
I
have
a
pipeline
here.
That
does
quite
a
few
different
steps
and
I'm
going
to
first
edit
this
pipeline
just
to
give
you
to
kick
off
a
build,
so
you
kind
of
have
an
idea
of
what
it's,
what
everything
is
doing
and
and
we'll
walk
through
it.
So
the
first
thing
I
do
in
here
is
I'm
going
to
just
say
hello
kubecon.
B
Directly
to
the
branch,
okay,
so
that's
kicking
off
a
while.
That's
kicking
off
a
a
build
I'm
going
to
explain
a
little
bit
about
what
this
is
doing.
First,
it's
it's
pointing
out
that
GitHub
has
a
ability
to
host
the
registry
as
a
service
for
for
within
the
builds
itself,
and
once
Docker
natively
supports
this.
You'll
no
longer
have
to
run
this
at
the
start.
B
Next,
that's
important
to
call
out
yeah
we
install
oras,
we
build
a
Docker
image
and
the
other
thing
that
is
is
nice
in
terms
of
making
it
convenient.
There
is
a
notation
setup
task
that
enables
you
to
use
that
secret,
that
you,
let's
say
your
organization,
uses,
for
instance,
to
assign
things
in
this
way
that
you
could
secure
your
build
and
ideally,
as
a
user,
you
would
never
even
really
need
to
you
know.
Personally,
you
know
have
access
to
the
certificate.
You
would
just
probably
have
your
build
system.
B
Have
your
certificate
at
least
a
different
certificate,
perhaps
than
a
personally
used
one
to
test
things
so
that
it's
more
secure
and
trustworthy,
and
then,
after
this
you
know
we're
going
to.
After
building
the
image
we're
going
to
sign
the
image
we're
going
to
generate
an
s-bomb,
we're
going
to
attach
use
the
oraz
attach
to
attach
the
s-bomb
and
then
we're
going
to
assign
that
that
s-bomb
and
all
of
the
artifacts
that
are
there.
So
I
think
we.
We
can
take
a
look
now.
Yeah.
A
B
So
we
can
see
here,
I
think
we're
actually
almost
done
yeah,
it's
almost
already
built,
and
one
of
these.
The
last
thing
that
is
important
to
call
out
is
that
you,
you
want
to
do
this
as
a
local
on
the
Local
Host
until
the
very
end,
because
what
you
may
want
to
do
is
during
that
process
of
doing
the
build
you
may
want
to
check.
B
For
you
know
if
it
has
vulnerabilities
I
may
want
to
stop
the
build
process,
because
you
don't
want
to
necessarily
pollute
your
registry
with
tons
of
extra
stuff
that
doesn't
really
qualify
for
production
and
at
the
end
we
can
use
this
OS
copy
to
just
go
from
the
local
build
host
up
to
the
actual
location
in
in
the
registry.
So
what
I
can
do
now
is
I
can
take
a
look
and
see
what
I
just
built
with
you
here
and
if
we
take
a
look
at
this
clear
this
out,.
B
Should
oras
discover
for
the
image
we
just
built
and
again
you
could
see
all
of
this
that
we
just
did
there.
It
was
about
a
minute
to
do
all
this,
to
create
the
s-bomb
great.
The
vulnerability
scan
sign
the
image
sign,
the
s-bomb.
All
those
things
are
done
in
a
very
fast
Manner,
and
now
how
do
we
enforce
it?
B
We
can
enforce
it.
We
have
ratify
as
a
binary
and
one
of
the
things
that
ratify
has
is
a
local
configuration,
so
it
allows
you
to
show
what
certificates
that
that
you
are
using.
So
in
this
case
ratify
has
this
config.
It's
saying
there
are
a
number
of
different
verifiers
that
you
could
verify
s-bombs
you
can
verify
license
Checkers.
B
You
know
it
is
open
source,
so
you
could
add
other
plugins
for
policy,
but
right
here
we're
just
using
the
notary,
signature,
verification
and
we're
using
just
this
particular
trusted
certificate,
and
so
with
that
we
can
do
a
ratify
verify
locally
and
and
actually
see
that
these
different
images
will
will
verify
on
from
a
binary.
So
you
could
imagine
here
again
you
could
put
this
on
an
offline
scenario
or
in
a
pipeline
to
verify
before
you
deploy
and
then
Within
kubernetes.
B
A
A
I
also
want
to
talk
about
sketch,
which
is
a
standard
that
a
lot
of
the
people
who
are
working
on
Nursery
are
really
interested
in
it's
a
draft
ietf
standard
for
supply
chain
security
in
particular.
It's
got
us.
It
supports
a
set
of
distributed
transparency
logs,
which
still
support
revocation,
and
they
also
support,
did
identities.
A
You
know
as
part
of
as
part
of
the
log,
so
you
can
and
so
there's
a
there's
a
and
there's
a
whole
set
of
verification
infrastructures.
It's
it's
a
very
early
stages,
but
there's
a
there's
an
amount
of
interest
in
this
and
there's
a
blog
post
there
that
Steve,
Lasker,
wrote
and
I
think
we'll
be
pres,
doing
a
presentation
to
the
nursery
working
group
about
what
you
know
why
this
is
interesting
and
what
kind
of
things
that
people
are
thinking
about.
A
Integrating
back
into
notary
as
this
is
developed
from
90
ietf,
there's
also
a
whole
bunch
more
work
that
we
that's
ongoing,
that
we
kind
of
haven't
had
time
to
cover.
So
there's
a
lot
you
know
to
do
in
terms
of,
in
particular.
The
problem
I
was
talking
about
before,
like
how
you,
how
do
we
roll
out
signing
infrastructure
from
a
world
where
things
are
not
signed
to
where
they
are
signed
and
how
we
actually
get
that
done.
We're
we're
doing
some
planning
work
around.
A
C
B
A
Do
it
oh
yeah,
briefly,
very
briefly:
okay,
sorry
so
yeah,
so
yeah,
we're
also
out
of
time,
I,
think
or
almost
out
of
time.
I
think
we've
got
like
one
minute,
so
we
could.
Probably
okay,
we've
got
five
minutes.
Oh
we
have
got
tons
of
questions.
Then,
okay,
we've
got
to
have
questions.
I
thought
we
were.
B
A
D
A
S
I
think
I
think
that
there
there
is
a
there
is
a
whole
bunch
of
collaborative
I
mean
I,
think
you
know
a
lot
of
the
thing.
The
building
blocks
off
are
common
or
becoming
like
things
like
you
know,
reference
types
and
so
on
were
all
done
together.
So
I
think
that
yeah
yeah
I
think
that
I
think
we
there's
definitely
a
kind
of
convergence
in
there
and
a
lot
of
those
Yeah.
B
Well,
yeah
like
so
so,
for
instance,
skit
would
be
one.
That's
an
ietf
standard
would
love
to
see
participation
there
as
well.
That's
you
know,
International
standard
and
then
oci
you
know
is
something
we
called
out
earlier.
That
was,
you
know,
Josh
from
chain
guard
and
Sanjay
worked
on
together.
So
in.
A
B
A
E
A
D
D
A
D
A
It
yet
so
we're
still
we're
still,
but
that's,
but
the
aim
is
the
absolutely.
The
aim
is
for
us
to
use
in
Toto
for
the
validation
of
the
stuff
that
we're
shipping
as
as
Docker,
and
that's
not
you
know,
there's
no
part
of
the
nursery
project.
That's
you
know
we're
we're
just
using
we're
working
with
everyone
else
on
on
that
stuff.
B
Yeah
I,
don't
know,
there's
another
I,
don't
know
if
you're
we
haven't
covered
it
in
here,
but
in
terms
of
trying
to
help
with
things
we
we
also
Microsoft.
We
announced
like
a
open
source
software
security
framework
and
has
a
maturity
model
and
other
things,
and
we
have
that,
like
now
being
a
part
of
the
working
group
in
in
cncf.
So
there's
a
lot
of
things
that
are
were
involved
in
standards
and
as
a
whole,
I'd
say:
that's
that
was
part
of
part
of
what
we've
been
talking
about
is
that's.
C
C
C
B
So
it
the
the
ratify
admission,
controller
functionality,
the
the
thing
that
attaches
to
kubernetes
it
runs
in
a
pod.
That's
there
that
pod
actually
has
mounted
the
public
certificates
that
that
it,
that
you
trust,
right
and
ratify
will
actually
locally
try
and
go
and-
and
you
know,
verify
that
signature
on
the
cluster
inside
the
pod,
which
is
what
I
showed
you
in
the
logs.
So
it's
using
the
it
actually
uses
the
notation
go
library,
and
so
it's
it's
using
that
go
library
in
the
ratify
binary
to
to
check
the
the
signatures.