►
From YouTube: Notary v2: Deep Dive and Open Issues - Justin Cormack, Docker & Steve Lasker, Microsoft
Description
Don’t miss out! Join us at our upcoming hybrid event: KubeCon + CloudNativeCon North America 2022 from October 24-28 in Detroit (and online!). 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 v2: Deep Dive and Open Issues - Justin Cormack, Docker & Steve Lasker, Microsoft
Notary v2 is a community project to solve the issues that the existing Notary project has that have hindered widespread adoption. The project is a community initiative with the main registry operators, including Docker, Microsoft and Amazon, as well as a broad community of other interested parties and end users. This talk will cover an overview of the project status and cover the open issues and current working areas for the project, around formats and standardisation, open security issues and future work.
B
Hi,
so
I'm
steve
lasker,
I
work
in
azure
and
a
couple
years
ago
we
thought
you
know
we
was
important
to
revive
the
signing
efforts
and
containers,
because
it
was
a
pretty
important
effort
and
there's
about
two
and
a
half
three.
I
was
pre-covered,
so
it
was
about
three
years
ago
and
we
basically
got
together
a
bunch
of
the
people
across
the
various
clouds
and
providers,
and
I
was
like
we
need
to
actually
solve
the
signing
problems
with
the
the
core
issues
of
promotion,
workflows
and
things
we'll
talk
about
today.
A
Yeah,
so
we're
going
to
talk
about
a
little
bit
about
the
goals
in
azure
v2
we're
going
to
talk
about
some
of
the
workflows
that
people
wanted
us
to
support
and
want
us
to
support.
I'm
going
to
talk
about
kind
of
supply
chain,
artifacts
that
people
are
interested
in
storing
in
registries
we're
going
to
deal
with
the
kind
of
question
of
who
do
you
trust,
and
why
for
signatures
and
we're
going
to
go
through
some
of
the
open
issues
that
are
still
being
resolved
and
then,
where
what
the
state
of
the
project
really
is.
A
A
We've
all
been
talking
to
our
customers
about
what
they
would
like
in
signing
and
that's
really
driven
that
the
kind
of
way
we've
looked
at
trying
to
solve
the
problem,
we're
looking
to
really
invest
in
and
extend
existing
services
in
particular
registries
registries
are
really
important
and
everyone
has
them
integrated
in
their
workflow
and
they
understand
the
security
properties,
and
things
like
that.
So
it's
very
important
that
we
just
build
on
that
infrastructure
rather
than
try
and
replace
it.
A
A
It's
very
important.
We
feel
that-
and
it
was
one
of
the
problems
with
kind
of
naturally
b1,
that
the
signatures
and
the
other
supply
chain
aspects
were
not
really
stored.
Within
with
the
images
they
were
stored,
kind
of
in
a
separate
sidecar
service
and
that's
been
a
kind
of
driving
point
the
whole
through
all
through
the
v2
is
like
this
integrate
supply
chain
metadata
into
the
into
the
image.
It's
really
all
about.
A
You
know
getting
integrity
from
build
all
the
way
through
to
production,
making
sure
it's
the
same
image
and
you
understand
what's
going
what's
happening
and
people
have
a
lot
of
workflows
where
they
take
say
you
know:
docker
have
public
images
like
official
images,
move
into
private
registries
and
or
have
different
dev
and
staging
registries,
and
all
those
kind
of
things
where
people
are
moving
images
around.
It's
been
really
important
to
support
again.
That
was
one
of
the
problems
with
nature.
A
V1
was
that
signatures
didn't
move
with
with
the
images
and
those
these
kind
of
workflows.
Where
you
you
know
you
you
want,
you
want
your
images
to
be
in
different
places
for
different
functions
for
different
production
systems.
If
you
become
really
important,
we'll
talk
a
bit
more
about
that
in
a
bit
as
well.
B
B
B
So
in
the
concept
of
who
do
you
trust?
You
know,
if
I
navigate
to
evil.com
it's
a
real
site,
it's
got
random
stuff
on
there,
but
the
evil.com
is
not
signed.
There
is
no
https
certificate
on
it
and
the
idea
here
is
that
we
wanted
to
be
able
to
make
a
comparison
to
how
we
think
about
the
browser
model,
because
there
are
a
lot
of
analogies
here
and.
A
B
So,
in
this
case,
there's
no
cert,
the
browser
tells
you
there's
no
cert,
you
can
kind
of,
and
you
can
navigate
through
and
you
can
find
more
information.
So
you
kind
of
make
a
very
easy
decision.
There's
no
certificate,
there's
no
identity
to
who
this
evil.com
people
are
so
no
cert,
no
trust
kind
of
logical.
B
But
let's
look
at
some
other
ones,
so
my
kids
are
now
out
of
college,
but
my
daughter
was
doing
high
school
research
or
school.
I
knew
it
was
high
school
at
the
time,
pre-browser
browser
pop-ups,
so
the
only
thing
on
the
internet
at
the
time
was
dot-com,
so
she
went
off
and
did
whitehouse.com
and
was
kind
of
a
little
surprised
about
what
she
found.
B
B
B
There
isn't
any
real
discernible
difference
between
the
two
they're,
both
completely
signed,
so
it's
like,
which
one
am
I
supposed
to
trust
there.
If
I
go
to
microsoft.com,
there's
a
cert
chain
there
as
a
company
there's
some
extra
information,
that's
popped
up
that
I
can
do
more
research
on
if
I
so
choose.
B
But
if
I
look
at
the
search
chain,
there's
a
certificate
there,
it
roots
up,
it
happens
to
root
up
to
a
different
route
chain,
but
it
doesn't
really
matter
much
because
there
are
a
lot
of
software
companies
and
other
companies
that
have
a
lot
of
business
that
they
count
on
right.
What
is
the
internet
based
on
there's
various
sites
out
there
that
it's
very
important
for
them
to
encrypt
and
have
good
security
models
on
there?
So
it's
very
difficult
to
discern
any
of
these
from
any
level
of
difference.
A
So
we
we
have
different
kind
of
levels
of
trust
and
different
kind
of
rules
about
who
you
trust.
You
know
it's
kind
of
not
it's
not
quite
the
same
as
the
browser
model,
because
you're
not
just
trying
to
authenticate
that
you
just
get
encryption
you're,
actually
trying
to
make
decisions
about
policies
about
things
like
what.
B
A
In
production,
so
it's
you
know
what
you
put
in
production
on
your
developer
laptop
might
be
very
difficult
different
from
what
you
put
in
production
on
a
you
know,
a
banking
site,
that's
serving
and
serving
your
end
customers.
So
we
need
to
actually
think
about
how
to
have
rules
that
let
you
configure
different
kind
of
policies
for
these
different
kinds
of
use
case.
B
And
they're
similar
in
the
same
way,
also
right
like
what
I
might
want
to
allow
is
sites
that
I
can
browse
and
do
research
on
are
probably
different
than
the
filtered
sites
that
I
allow
my
kid
to
look
at
dev
production
very
similar
things
right
and
browsers
have
ways
to
set
up
safe
limits,
and
you
can
opt
in
sites
that
you
allow
or
not.
Your
company
can
provide
group
policy
on
things.
A
We
also
have
different
kind
of
routes
and
kinds
of
trust,
and
initially
we
really
want
to
make
this
very
configurable
for
the
for
the
end
user
to
make
a
choice.
So
you
might
trust
microsoft
to
sign,
excel
and
word
and
nothing
else,
because
there's
that's
the
software,
you
you
get
from
microsoft
and
you
trust
the
upstream.
You
might
want
everything
else
to
come
from
your
own
organization
certificate.
So
perhaps
you
use
you
know
you
want
to
have
a
spiffy
set
up
with
ephemeral
signatures
for
your
build,
going
back
to
your
route
and
that's
fine.
A
You
might
want
to
trust
things
that
you've
inspected
the
bill
of
materials
on
it
and
you've
just
and
you
made
certain
choices
about
what's
in
the
image
and
whether
you,
whether
you're,
prepared
to
run
an
image
based
on
the
contents
or
other
kinds
of
attribution
about
how
it
was
built
where
it
was
built
who
was
built
by
and
all
those
and
we're
seeing
a
lot
more
of
that.
So
we
really
want
to
provide
a
very
flexible
configurable
model
where
you
can
make
these
decisions
and
perhaps
change
them
over
time.
Yeah.
B
I
mean
in
your
dev
environment,
you're,
probably
doing
some
pretty
scary
stuff
with
compilers
and
file
parsers
and
other.
You
know,
powerful
tools
that
you
need
in
your
build
environment,
that
same
software,
company
might
produce
images
and
or
project
project
or
company
might
produce
images
that
you
do
want
to
use
in
production
as
well,
so
the
same
signing
authority
in
that
case,
won't
let
you
differentiate
deb
to
production.
B
There
might
be
some
other
claims
or
metadata
that
you
want
to
make
sure
is
available
as
well,
that
claims
and
metadata
you
want
to
make
sure
it's
signed,
because
you
know
this
guy
justin
over
here
might
make
some
claim
about
something
that
doesn't
mean
that
you
actually
trust
his
decision.
So
you
want
to
have
identity
associated
with
all
the
information
that
you
have
so
this
one's
kind
of
interesting.
So
this
is
where
we
think
about,
and
this
is
how
I
think,
in
some
ways,
notary
v1,
just
the
environment-
wasn't
mature
enough.
B
B
Maybe
they
should.
You
know,
want
to
check
the
signature
first
to
see
if
it's
really
from
a
company,
they
trust
before
they
deploy
it.
So
in
that
case
it
was
a
little
reversed,
but
what
we
also
see
is
the
customers
that
are
trying
to
do.
This
have
security
expectations,
and
this
was
the
interesting
thing
is
you
know
it
been
at
microsoft,
a
while
been
working
on
enterprise
enterprise
customers
for
a
long
time
is
the
containers
are
just
the
latest
tech
they
have
a
set
of
security
bars
that
they
want
where
things
are
signed.
B
A
Yeah
we're
seeing
much
more
of
a
trend.
People
really
want
to
control
what
comes
into
their
production
environments.
They
want
to
gate
everything.
First,
they
don't
want
to
pull
in
uncontrolled
ways.
They
want
to
basically
pull
and
gate,
which
is
partly
why
we
need
the
signatures
attached
and
and
all
the
metadata
attached
to
the
artifact,
so
that
you
can
bring
it
all
into
the
environment,
better,
better
sort
of
at
entry
point
and
then,
basically,
you
know,
use
it
safely
from
there
now.
B
Do
you
really
want
to
pull
something
from
the
internet
into
directly
into
your
production
environment
right,
like
who's
got
a
refrigerator
at
home
or
in
their
hotel
like
we,
we
keep
things
close
when
you
want
something
to
eat
or
drink,
you
want
to
make
sure
it's
there.
You
go
and
replenish
it,
but
this
is
there's
nothing
much
difference
between
the
technology
and
what
we
do
in
many
other.
B
So
and
there's
multiple
companies
right.
This
is
not
people
aren't
using
just
one
project
or
one
company
there's
multiple
out
there
and
they
want
to
be
able
to
look
to
some
third
parties
necessarily
to
hey.
Is
there
some
clearinghouse
for
some
of
this?
So
this
is
where
docker
hub
can
come
in
really
well
and
they've.
B
So
in
this
case
the
small
company
webit
networks
can
publish
their
stuff
to
docker
hub
notice,
there's
a
single
signature
there,
because
it
comes
from
them
and
notice.
It's
not
just
the
container
image,
but
it's
the
you
know
the
signatures.
It's
the
claims.
It's
the
scan
results,
it's
other
metadata
that
they
want
to
make
available.
B
There's
a
subset
of
that
content
on
docker
hub
that
they
will
say
is
trusted
content
they've
done
some
extra
effort,
whether
they
built
it
or
scanned
it
or
done
some
policy
on
and
said
look.
This
is
we've
taken
some
special
look
at
this
and
this
content
is
different
and
therefore
it
gets
a
docker
hub
signature,
there's
other
content
that
isn't
certified
by
them
or
trusted
right.
It
could
just
be
out
there
for
discoverability
purposes.
B
B
How
can
a
company
configure
what
that
policy
is?
So
in
this
case,
what
we've
set
up
is
a
there's,
a
trust
policy
that
says
they
actually
don't
trust
web
at
networks
because
they
don't
know
who
they
are,
but
they
trust
docker
hub
and
they
trust
a
couple
other
vendors
as
well.
So
this
is
a
way
that
they
can
choose
what
content
they
will
allow.
In
to
their
environment
and
then,
as
they
scan
that
provide
the
network,
the
policies
they
want
for
their
company,
they
could
sign
it
with
their
own
signature.
A
So
you
can
basically
configure
policies
like
per
environment
in
different
ways,
so
you
can
say
which
keys
you
trust
and
we're
integrating
with.
You
know,
admission
controllers,
I
think
so
april
gatekeeper
and
other
policy
managers.
So
you
can
basically
configure
configure
those
possible
shows
in
the
demo
yeah.
A
So
the
signatures
are
associated
with
with
I
mean
we've
basically
got
a
had
got
a
model
here
where
we
have
kind
of
separated
signatures
so
that
you
can
assign
you
can
reference
reference,
the
artifact
that
they
sign.
We
make
sure
that
you
can
have
multiple
signatures
on
objects.
In
case
you
want
that
kind
of
workflow
signatures
move
around
with
the
artifact
you
can
we
sign.
Basically,
we
don't
require
you
to
pull
the
entire
object
to
check
the
signature.
B
I
mean
the
model
we
did
with
signatures
to
be
able
to
support
detached
workflows.
Is
we
want
to
be
able
to
put
things
in
a
registry
that
a
registry
doesn't
even
know
it's
a
signature?
It
doesn't
care,
so
we
can
associate
anything
because
if
you
look
at
your
deployment
scripts,
they
probably
say
like
net
monitor
colon
v1
or
net
monitor,
even
with
a
digest.
B
B
All
right,
so
every
good
demo
starts
with
a
docker
build
so
we'll
just
come
over
here
and
I'm
just
building
an
image
from,
in
this
case
a
git
repo
right,
so
nothing
special,
just
kind
of
the
standard
baseline
there
and
then
we'll
do
a
standard.
Docker
push
right,
nothing
magic!
The
point
here
is
that
I'm
building
and
pushing
to
a
private
registry
doesn't
matter
what
cloud
where,
wherever
you're
running
your
workload
use
the
registries
that
are
closest
because
your
fridge
is
nearby.
B
So
I
want
to
start
with
just
a
very
simple
sign
and
verify
now
I'll
use
a
test
cert
here
that
we
can
generate
it's
a
self-signed
insert
just
we're
just
starting
here,
we'll
show
where
we
can
have
a
remote
sign
start
here
in
a
minute,
but
I
just
got
an
x509
cert,
wherever
you
might
have
gotten
it
from
now.
I
can
sign
because
I've,
if
I
look
closely
notice,
I've
said
default.
B
So
when
I
generate
it,
I've
actually
set
it
up.
So
that
I
can
sign
with
that
key
by
default,
I
happen
to
so
I
had
mentioned
the
key
and
I'm
just
saying,
notation
sign
the
image
or
any
artifact
that
I'm
referencing.
This
happens
to
be
a
container
image.
The
net
monitor
v1
image
and
it
comes
back.
It's
like
okay,
it's
signed.
It's
literally
that
simple.
It's
based
on
a
notation
client
and
a
registry.
B
A
And,
of
course
it
fails
because
we
haven't,
we've
got
a
failed
by
default
policy,
because
this
is
a
self-signed
cert.
We
don't
know
anything
about
it.
We
haven't
set
it
up
in
our
environment,
so
we
actually
need
to
configure
that
we
actually
need
to
configure
that
we
actually
want
to
use
the
certificate.
B
A
Yeah
most
people
don't
really
want
to
keep
their
private
keys
on
their
laptops,
and
things
like
that,
so
one
of
those
really
strong
asks
we
had
was
that
for
most
almost
everyone
really
wants
to
keep
signing
keys
in
hardware,
which
means
in
some
sense
remote.
It
might
be
a
as
remote
as
a
ub
key
or
the
tpm
on
your
machine,
or
it
might
be
actually
in
in
a
cloud
provider,
key
storage
or
some
somewhere
else.
That's
not
basically
on
the
file
system
accessible
to
the
clients.
A
B
And
this
is
where
we
just
wanted
to
lean
into
the
infrastructure
that
our
customers
already
have.
We've
already
got
a
lot
of
infrastructure.
Here
we
want
to
leverage
that
that's
their
security
bar,
so
the
the
model
is
you
keep
your
private
keys,
private,
you
might
have
access
to
sign
them
and
those
key
providers.
The
keyboard
providers,
have
lots
of
logging
to
know
who
signed
them,
but
you
can't
you,
don't
have
the
right
to
take
the
private
key
out
and
put
it
on
the
internet
right.
B
A
B
Exactly
so,
then,
the
next
part
is
well.
There's
lots
of
keyboard
providers
out
there
there's
lots
of
signing
services
out
there.
We
don't
want
notation
to
have
to
track
every
one
of
those
we
don't
want.
Anybody
wants
to
write
a
key
vault
provider.
Sorry
a
a
plug-in
to
have
to
come
to
the
notary.
Maintainers
and
like
can
I
please
check
this
into
your
source
code.
There
should
be
a
specification
that
says
here's
how
you
write
one.
So
that's
what
we've
set
up
and
we've.
B
Basically
it
doesn't
even
matter
what
language
you
write
it
in,
because
it
just
does
binary
calls
and
does
standard
and
standard
out
to
get
the
information
to
it.
So
really
nice,
it
doesn't
doesn't
require
you
to
even
use.
In
this
case
we
use
go
for
the
notation
client
and
if,
as
you
want
to
rev
those
you
completely
build
it
all
on
your
own,
you
completely
keep
it
all
on
your
own.
You
can
service
it
and
there's
nobody.
Nobody
has
to
know
about
it
outside
of
whoever's
doing
it.
B
So,
let's
take
a
look
at
how
we
can
do
that
here.
So
what
we've
got
is.
We've
happened
to
wrote
right,
one
for
azure
key
vault
aws
is
writing
theirs.
We
want
to
get
one
for
hashi
kivo.
As
an
example,
we
haven't
had
a
chance
to
do
that
yet
so,
if
somebody
wants
to
write
one,
that
would
be
great
I've
already
configured
that
with
a
azure
keyboard
provider.
Again
anybody
can
write
one
and
I'm
just
gonna.
I
need
to
get
the
key
id
now.
B
B
B
If
I
look
at
the
key
list,
we
point
out
that
we've
been
gotten
used
to
very
wide
monitors
at
home,
so
we
probably
need
to
rethink
about
how
we
format
that
output,
but
then
I
can
just
simply
say
no
different
than
I
did
with
the
self
sign
key.
I'm
now
doing
a
sign
with
a
key
that
we've
got
locked
up
in
a
key
vault.
I
don't
have
any
access
to
other
than
to
do
sign.
B
B
B
Now
that's
great,
I
can
do
that
on
my
laptop,
but
I
don't
think
we're
running
too
many
workloads,
probably
from
our
laptop,
maybe
some
ml
scenarios.
I
mean
that's
not
completely
true,
but
there's
definitely
some
it's.
How
do
I
get
this
into
some
kind
of
production
or
you
know
other
environments,
and
this
is
where
we
wanted
to
integrate
with
the
existing
systems.
So
we've
got
a
kubernetes
cluster
here
and
I've
got
two
namespaces.
A
B
There's
a
secured
and
a
not
secured
namespace
we're
going
to
leverage.
You
know
the
policy
managers
in
this
case
gatekeeper
and
we've
got
a
project
we
call
ratify,
which
is
knows
how
to
read
those
references
and
do
validations.
You
can
do
validations
on
signatures.
You
can
do
validations
on
s-bombs,
it's
completely
pluggable
model.
B
But
now
I
want
to
lock
down
that
secured
namespace
right.
We
want
to
be
able
to
say
that
only
things
running
in
that
should
be
allowed
to
be
run
in
that
namespace
that
are
actually
signed
by
a
key
that
I'm
configuring
and
I
happen
to
have
that
public
key
stored
in
a
key
vault
in
this
case.
So
I'm
going
to
go
grab
that
key,
because
these
are
you
know,
ephemeral
nodes.
I
don't
have
them
deployed
everywhere.
B
B
So
then
I'm
just
going
to
take
I'm
going
to
do
a
helm
chart
for
ratify
and
I'm
going
to
give
it
the
public
key
that
I
wanted
to
secure.
So
I'm
just
doing
a
helm
install
and
then
I'm
saying
you
know
there's
our
register
well.
Registry
cred
set
up,
but
basically
here
is
the
public
key
that
I
want
you
to
use.
B
B
B
Okay,
so
great
we've
locked
that
down,
can
I
run
anything
in
there.
Well,
remember
we
signed
our
net
monitor
image
with
two
keys.
We
signed
it
with
a
self-signed
private
key
which
it
goes
like
whatever,
because
I've
configured
that
cluster
to
use
the
acme
rockets
or
the
wabit
networks
key
in
this
case,
so
there's
a
key
that
I've
set
up
only
allow
stuff
that's
signed
with
that
key,
and
so
it
was
scheduled
and
life
is
good.
B
Now
we
talked
about
the
promotion
workflow.
What
if
I
do
want
to
run
the
nginx
image
in
that
environment?
Should
I
just
allow
anything,
that's
unsigned
if
it
if
it
equals
nginx?
Well
what
what?
How
does
that?
Is
that
really
what
I
want
do
I
want
to
constantly
pull
updates
from
docker
hub
and
and
deploy
it
well,
there's
a
hundred
different
connections
that
could
be
down
having
nothing
to
do
with
docker
hub.
Between
that
point,
there
could
be
a
security
update
to
nginx
that
might
actually
not
work
for
my
environment.
B
B
B
So
there's
a
set
of
issues
and
but
effectively
it
is
the
best
thing
that
we
have
today.
It's
like
okay,
I'm
making
that
decision
to
be
able
to
promote
it.
Now,
I'm
actually
going
to
do
something.
A
little
interesting
here
is:
I'm
actually
going
to
take
the
output
of
that
scan
and
I'm
actually
going
to
save
it
to
engine
gen
x.
B
Oh
engine
x,
scan
okay.
I
forgot
the
json
file
so
I'll
have
to
I'll
remember
how
to
fix
that
so
it'll
save
it
as
nginx
scan,
not
json.
It
should
have
been,
but
I
forgot
to
do
that
so
now,
I'm
going
to
tag
that
image
so
that
it
it
is
going
to
be
set
up
so
for
the
registry
that
I
want
to
deploy
from,
I
don't
want
to
deploy
from
docker
hub.
I
want
to
import
from
docker
hub
into
my
environment.
B
B
We
go
see
all
right,
so
I
just
have
to
do
the
item.
Potency
thing
and
finish
up
the
last
piece
come
on
there.
We
go
okay,
so
the
image
is
there,
but
remember.
I
also
want
to
associate
that
nginx
scan
file
that
I
forgot
to
put
dot
json
on.
That's
what
I
was
just
fixing
there
I'm
going
to
push
that
up
also,
so
this
I'm
using
the
rs
client
and
basically
I
want
to
push
to
the
nginx
repo,
I'm
going
to
name
it.
B
Snick
scan
v1
and
the
subject
is
that
net
sorry,
the
nginx
121.6
image.
So
when
I
push
that
up,
I'm
now
saying
hey,
please
store
that
scan
result
with
the
image
as
well,
and
then
we're
going
to
sign
come
on
internet
there
we
go
so
now
I'm
going
to
sign
that
image.
So
now
I've
actually
got
two
things
that
I've
associated
with
it
right.
We've
got
the
scan
result
and
the
signature.
B
So
now,
if
I
do
an
or
as
discover
again
take
the
nginx
image
the
tag
and
that's
the
only
named
reference-
I
know
what
else
is
hanging
off
of
that,
and
you
see
that
now
I've
got
the
snick
scan
and
the
signature
both
right.
So
that's
kind
of
nice.
I
can
now
have
my
objects
together.
The
only
the
only
instances
that
I
have
here
is
a
registry
and
the
notation
in
nora's
clients.
B
Okay,
so
now
I
can
get
back
to,
I
do
want
to
run
that
nginx
image.
So
now
I
can
say,
run
engine
x,
I'm
naming
it
nginx,
but
notice,
I'm
pulling
it
from
my
private
registry
that
has
been
signed
with
the
key
that
I
trust,
because
I've
done
the
verification
on
that
workflow
and
it's
often
scheduled
right,
that's
kind
of
the
beauty
of
it.
Well,
that's
that's!
Basically
it
so
cool,
let's
kind
of
think
about
that
for
a
second,
so
we
have
several
different
tools
that
we
were
using.
B
In
this
case
we
were
signing
and
we
were
generating
scan
results.
We
want
all
that
information
to
be
promoted.
Remember
that
animation
we
did
where
we
said
we
want
to
take
the
public
stuff,
put
it
into
our
private
registries,
because
that
starts
to
get
inside
our
environment,
we've
secured
it
and
we
can
promote
it.
B
Well,
I
want
to
show
one
more
quick
one
here
where,
if
I
want
to
copy
that
content
from
one
registry
to
another,
this
aura's
client
doesn't
know
anything
about
scan
results
doesn't
know
anything
about
signatures.
It
just
says
copy
things
from
this
named
reference
in
wabit
networks
to
acme
rockets
and
because
it
can
read
those
references,
it
doesn't
need
to
know
what
they
are.
A
A
So,
where
we
are
really
we're
finishing
up
release
candidate
one
this
month,
microsoft
is
shipping.
A
load
of
example
sign
things
that
you
can
test
right
now,
we'll
be
starting
to
ship.
Docker
official
images
signed
with
us
shortly
as
well,
so
there'll
be
more
to
test.
But
if
you
want
some
test,
images
now
and
rc1
will
be
compatible
with
the
future
format,
so
it
should
be
should
be
good
to
test
going
on.
There's
more
more
links
there
to
give
you
some
something.
B
The
idea
is
like
we
have
to
like
we're
a
software
company
as
microsoft.
We
need
to
ship
our
software
with
signatures
and
s-bombs
the
executive
order
in
the
u.s
and
all
kinds
of
other
things.
We
want
to
make
sure
we
can
start
testing
this
workflow.
So
we'll
that's
kind
of
some
stuff.
That's
available
there.
A
Yeah
go
ahead
and
we
go
we're
finalizing
the
specs
at
the
moment,
just
trying
to
put
things
together
and
you
know,
we've
got
a
alpha
release
working
towards
the
rc,
and
you
know:
we've
shown
the
things
that
some
of
the
key
vault
providers
and
some
of
these
other
example
stuffs,
there's
more
going
on
with
aws,
is
doing
work
on
their
key
signing
provider.
As
I
said,
we're
working
on
getting
official
images
signed
and
things,
so
you
can
kind
of
test
this
all
out
and
provide.
B
So
it's
just
it's
okay,
so
the
copy
was
done.
Let
me
just
kind
of
do
one
more,
so
we
were
able
to
just
let
that
let
that
sink
in
there
for
a
second,
we
wanted
to
be
able
to
copy
that
graph
from
one
registry
to
another
and
so
notice.
I'm
now
said:
hey
auras
discover
what's
on
the
acme
rockets
registry,
for
what
I
copied.
So
it
will
give
us
that
list
very
exciting.
A
We've
still
got
a
bunch
of
things
that
going
on
we're
looking
at
additional
work
on
identities,
not
everyone
has
an
x,
509
infrastructure,
lots
of
larger
companies
do
and
lots
of
software
publishing
organizations
do
but
individual
developers
generally
don't
so
we're.
Looking
at
support
for
ssh
keys
and
policy
around
which
identities
do
you
trust
for
what
there's
kind
of
a
lot
of
you
know
kind
of
a
lot
of
options.
A
There
still
still
lots
of
work
to
do
on
there,
we're
looking
at
things
like
inline
signatures
for
when
we're
originating
content
with
signatures
straight
off,
but
yeah.
This
is
all
designed
to
be
extensible
framework
that
supports
lots
of
different
use
cases
so
come
along
and
tell
us
what
your
use
cases
are.
What
you
need.