All right, so first of all, thanks for staying with us on Sunday, and for sending the SOMROM of it as part of their organizers, I'm really happy to see this move.
And so we have been going through all of those cool use cases and complex, like really complex and complex tools to generate lessons and analyzing how companies, big companies have been doing it, and like going deep into the research of how SOMROMs are composed.
So I was thinking that I wanted to do like my talk as a kind of pivot as we are shifting towards the more discussion part of the bedroom.
And so as you have been hearing from folks right now, a lot of folks working on SOMROMs are starting to get concerned about what's actually in those documents.
And I think when Thomas opened the bedroom today, the first thing he said was, well, those dependencies that you're getting, they may not be correct, right?
So I thought that it would be, as we move to the latest part of the conference, it would be cool if we could get a few talking points just to see the conversation that's about to happen.
So my name is Lofa Garcia, and I am part of the SBDX community. I am a contributor to SBDX and some of the tools. I maintain a bunch of open source tools that generate and consume SOMROMs, and that help visualize them.
I am also part of the Kubernetes project. I am part of Kubernetes to Release, and I work there mostly on the supply chain security of the project. And yeah, I like riding my bike.
I'm based in Mexico City, and I am a staff engineer with Chinger, which is a company devoted to supply chain security.
So as you heard from probably every speaker today, the goal of having an SOMROM is getting a document which you can actually use for something.
And there are many concerns about SOMROMs flying around in the world today, because there are particular use cases, and some people will argue that SOMROMs may not be necessarily incomplete if they're not suitable for one case or the other.
And this is true, but instead of trying to picture ourselves like generating a next one from the position of like a large company or whatever, I felt that it was more appropriate to discuss today that how...
I mean, I am assuming a lot of people here are maintainers of open source projects, and sometimes very small open source projects like one maintainer small.
And I think it's important to start considering that when those large companies are going to use your projects, your library, important in that model that you write,
the SOM that you give them can really make a difference in several areas.
Like first, you can make their life easier because you're handing them more complete information which they can act on.
And the other one is we as the open source community become better citizens of the supply chain, like generating the information that pertains to us is a much more responsible thing to do.
So what happens when you open a next one?
Well, today you can get all sorts of surprises.
Sometimes there's nothing in there.
You open the SOM and it's empty.
Sometimes you don't have absolutely any information that lets you determine what that SOM is describing.
So it's simply just pointing to the same black box that you can look from the outside.
Or the other is what happens if are you sure that the SOM is really describing what you're expecting to and you're not getting caught by someone?
Well, that information needs to be in the SOM in order to ensure that importance.
It needs to be in the SOM in order to ensure that it's actually describing that piece of software that you're distributing.
So I'm going to give you a few examples.
I'm not trying to name names and that's why I chose projects that I'm involved with.
Both good and bad.
So this is the first one.
This is our company has a Linux distribution which is already shipping with S-bombs built in.
And we generate those S-bombs at build time for all of the packages.
And you can see the structure here of one of the S-bombs.
This is like a visualization of the S-bombs using the Kubernetes BOMB tool which lets you ingest SPDX documents and see how they're structured inside.
And as you can see, we try to, in the Linux distribution, add a lot of detail to the S-bombs as much as we can to just guide whoever is using those S-bombs to do smart decisions with the information they have in them.
So if you look at some of, this is a fragment of the S-bombs.
And I mean, some information is there.
Some information is, for example, the licenses, the license concluded fields.
They are marked as no assertion, but you can omit those, for example, if you want.
But we have the license from the project, from the actual operating system package.
We have some identifiers, things like that, so it's pretty complete.
It's obviously not perfect, but we try, and we try to add as much information as we can.
But then, let me show you another S-bomb from another popular open source project.
This is part of the Kubernetes S-bomb.
This is part of the S-bomb, like the structure, a little fragment of the structure of the S-bomb
that we generate when we put out a new Kubernetes release.
And this is describing, for example, the tables which we put out with every release.
One of the tables of the Qube API server, the list of files.
So we also try to add information.
Two S-bombs with Kubernetes, one with the artifacts, one with the source code,
which are linked one to each other.
And so we also think that those are fairly complete S-bombs.
But now, I opened an S-bomb in a popular open source project
and tried to generate the structure like this.
I'm not going to say which project it is.
It's just one I'm involved with and we should be doing a better job there.
And you can guess many reasons of why this is showing zero things, but we can go over this.
So as you can see, you can really enrich an S-bomb with a lot of information,
and some of it can be more important than other things.
But I've been thinking, well, what's the most important details that you can add to the S-bomb?
So the first one is, and by the way, most of this, you already heard it through the day
if you've been sitting in most of the conferences.
So we're going to go one by one.
So the first one is syntactic correctness.
You would expect that most tools generating S-bdx or cyclone DX S-bombs
do the basic job of just making a compliant document.
Well, the reality is that they're not so.
I picture this guy from Apollo 13 that tries to fit the square peg in the round hole or the other way around.
Because if you cannot ingest an S-bomb, so what's the point, right?
And even if you have tried to somehow hack the document or ingest it somehow,
the reality is that most tools that consume S-bombs today do not have a clear strategy of deprecating the documents.
And most importantly, not clear and also not predictable.
So if a tool tries to somehow ignore errors or whatever, the behavior may not be consistent.
So ensure that any S-bomb that you're producing or requesting at least complies with syntactic rules of the standard you're using.
The second one, dependency data.
And this is a little bit related to the first one.
I've seen S-bombs.
So since I work with a lot of open source tools and my job also has to do with S-bombs,
I've seen a lot of tools producing S-bombs.
And so for example, one variant of the bad S-bomb is, well, we'll just list like a table.
And that's your S-bomb, nothing else.
Or the obvious case of this S-bomb contains one thing, an RPM.
No dependency on nothing.
So we often use the analogy of the S-bomb being the nutritional label of software.
But without the dependency list, well, it's really worthless.
You can still use your S-bomb as the old checksum.txt if you want it.
But S-bomb's going to provide a lot more value than that.
Then the second one, licensing information.
We've heard a ton of talks today about licensing and why it may be important.
So the truth is, if you are publishing software, you're the most qualified person
to do the assessment of what the license to your software should be using.
And this applies both to the dependencies that you're pulling in.
And if you're redistributing any information,
ensure that the information about the licensing is going down the stream.
Because the tools that we've been seeing today try to do a good job
on helping people understand the licensing situation.
So I picture checking the passport as an example of the license.
The next one, semantic structure in the S-bomb.
This one also came during the discussion today.
So there are folks that think that S-bombs can be just the list of dependencies.
And it may be true, but then you start losing context on where those things fit.
For example, if you have just a list of dependencies,
and especially if they're not related to an artifact at the top of the S-bomb,
if you picture, so the S-bomb can be this beautiful graph of one node that spreads out
to lots of relationships in nodes.
So sometimes you'll see S-bombs that only have the list of dependencies,
and they don't talk about where those dependencies fit
if they're describing a concerning image, a binary, nothing.
So if you try to do something more sophisticated with that data,
you simply can't.
If you remember the S-bomb that I showed in the beginning that we built
with the Linux distribution, this is how we structure the container images
built from our Linux distribution.
So you have the container, the layers, and the packages,
like the OS packages, and then all of the files in its proper place.
And this information is actually coming from smaller S-bombs that get compiled
when we build the Linux distribution.
So each of the APKs of the distro have their own S-bomb describing that package.
And then when we build an image, we take all of those S-bombs
and give you one single S-bomb with a lot of that information
composed where it's supposed to be.
And without structure, you simply cannot do this.
And this is one image, but then if you go and make it more complex,
you can start thinking about multi-arch images, right?
And those need to have this information for each of the images
so the relationships start to become more complex.
And the way I try to picture is this, right?
So they give you a box of Legos without any instructions or anything.
If you use your imagination, probably you're going to build
something really beautiful, most likely not,
especially not the thing pictured in the box, right?
And so these are some of the reasons that I was thinking,
like if you have structure, then it's a guarantee at least
that the tool at least is looking at how the thing is composed
and where the information is flowing from
and lets you do more complex use cases for the documents.
Now, the next one.
This also has come two, three times today, software identifiers.
S-bombs need to be defining and naming the piece of software
as close as possible.
And software identifiers are one of the schemes
that you need in the document
in order to ensure that the piece of software
that S-bombs is describing is clearly identified.
And all of them have their problems,
especially CPE for example,
it's like really complex to get it right.
But the idea is there's going to be a tool down the stream
that it's going to benefit from that information.
So if you can add it, you're making sure that the S-bombs
can work well with those tools.
And this is kind of the idea of that.
So how many packages in the world named log, right?
So okay, log, but what's log?
There are thousands in every language,
like operating system packages, libraries named log.
So if you can have like a properly specified PURL,
CPE, both, that clearly define the piece of software
that the S-bombs is talking about,
then it can be better referenced and used by tools on the stream.
Now the supplier data, this is like a contentious one.
Then the reason why I added the supplier data
is because as software authors
sometimes we don't think that it's like an important field.
We simply, I mean, in most large open source projects
we just like copyright the project authors, right?
Like the editorial.
But the reality is that if you jump into any of the S-bombs
meetings that go on regularly,
you're going to hear all of the compliance folks
like I need a name to sue or, I don't know,
a different mentality than ours, but people need it.
And in fact, it's one of the requirements from MTA
as the minimum elements of S-bombs.
And this is a weird field because if you deal in
kind of more into security of the documents
that should be generated during the supply chain
and the software lifecycle.
This information is kind of, I don't know,
not really very useful because it can be forged
and you cannot trust it.
And so just having a name and an email,
well, like it serves compliance folks,
but to us it's kind of, well,
worthless really for security purposes, right?
But then you start thinking about what's
a supplier? Is it the author, the company right holder?
Is it the tool that compiles the thing,
the people who are distributing it?
And so, well, at least ensure that you're providing
some kind of information.
And the idea is know who's selling you your things, right?
Buy candy from that guy, probably not.
Yeah, exactly.
And get him from us.
Supplier data.
Oh, okay.
I messed up this slide.
So this one was supposed to be integrity data,
integrity data to prevent this kind of thing.
So when you, as you heard today also,
so S-bombs should be properly hashed,
like hashing as much as you can inside of the document,
when possible, when it makes sense,
especially when it can be verified.
So the idea is, is this piece of software that I'm naming
in the S-bomb the real deal?
Has it been corrupted or not?
But more importantly, having hashes lets you deal
the problem of the latest, right?
So sometimes you will not have a version,
but you can still reference that software artifact
inside of the S-bomb and other documents,
like Bex, for example, via the hashes.
So you can think about the versioning system
and the software identifiers as links to external systems
outside of the S-bomb, like vulnerability databases,
like, for example, package repositories.
But internally, everything should be addressed
via the hash if possible.
So if I'm telling you this is the vulnerability document
for a piece of software, it should match with the hashes somehow.
And the idea is, well, once you start content addressing
the piece of software in the S-bomb, you cannot go wrong.
And, well, that's basically what I have.
And so I just wanted to let this open, you know,
kick the conversations that are about to happen
about this kind of thing inside of the documents.
And if there are any questions or whatever,
happy to take them.
And if not, you can reach me as Puerco in most systems
and Twitter, whatever.
So thank you.
Thank you.
Questions?
Questions.
Oh.
So I was going to ask about the supply and data.
And how much is that seen as the individual who wrote something
that is maybe an entity who is distributing it as an organization
or a software foundation?
Well, I would like to hear the opinions of the supplier
for another.
Yeah.
So what's basically, what's the role of the supplier data?
So what's the use of that field?
Yeah.
What should be filled in?
Is it an entity?
Yeah.
Should they feel like a person or an entity or a tool?
Yep.
Or?
Yeah.
So I have a question about the last ingredient that you mentioned.
So the integrity.
In your definition, does that also include signing
on the actual as well as itself?
Not really.
Rip in?
No, no.
I was going to go to that question before.
But if anybody has insights about how supplier data
is used in the organizations, now's the time to discuss it.
All right.
Yeah.
No.
So the way I've seen it required is, no, no.
This is the first one.
So the first one is, how is the supplier used?
And the way I've seen it is mostly from procurement people,
like asking for that information, and lawyers.
So that's the model, the two that I've seen asking
for the information more.
I'm coming from the security side of Hezbollah more,
so compliance is not my strong side.
But that's why I'm suggesting it.
At one point, sorry.
Yeah, as one data point, the way that we are using supplier data
is actually recording who supplies the software.
So not who wrote it, not who created or something like that.
If we got it from an upstream distribution repo,
we put the upstream distribution repo for that.
Again, record what we know, that's the only thing that I know.
And so the other question is, so does the integrity point
consider also signing of the S1?
And yes, but not in this case.
So integrity, like signing of the S1 is mostly done
outside of the S1.
And that touches on trusting the S1, which is a whole other kind
of worms.
But I mean, it is, but not in the contents of the documents.
How can I make sure an S1 tiers to these principles?
Is there something like benchmarks?
Or I give it a score of 8.0 from 10.
That's a good S1.
Well, there are tools then.
Yeah, I repeat the question.
So how can I know?
Sorry, I didn't get a lot of sleep.
How can I make sure that the S1 really complies to these things
here?
So there are a couple of tools that do a validation of the S1,
like scoring, try to do the scoring.
So eBay has a tool called S1 Scorecard.
Then there's the NTIA compliance checker from SPDX.
I'm not sure.
I don't know.
Are the ender folks here still?
OK, so I seem to remember that they were handling some of that
as well.
But there are a couple of tools out there.
It's more like a remark, but it's a bit surprising to mention
Open Chain that much.
Open Chain, the goal is to trust from the suppliers
so you can trust the S1's from the suppliers.
So yeah, what Nico said is that Open Chain has touches on the idea
of trusting the S1 on the supplier and those sorts.
And in observation, this is having looked at Python,
and the metadata that goes with Python packaging
is really inconsistent.
So how do you spell Apache 2?
How many different ways of putting Apache 2 license is amazing.
And actually, between releases, information disappears.
So this is really a message for the ones who are in the ecosystem,
put as much data in the ecosystem,
and the metadata that you can, because this is going to support...
Yeah, exactly.
Yeah, the comment is...
Because we were looking at a difference,
and we've got a new release of a package,
but there was one where there's a supplier gone.
Right, exactly.
And actually, the question is,
do we just use that on your matter?
Because we don't know where it's come from.
Yeah, the comment is that in Python,
sometimes between releases, information changes,
or disappears, or whatever.
So this is actually one of the things
that some of us would like to see happening,
like people working on packaging systems,
on language ecosystems, to start,
if not adding S-Bomb generation straight away in their tooling,
at least expose the information so that we,
S-Bomb toolmakers, can go in and extract them
from more trustable sources.
And...
Okay.
In regards to hashing,
how are you dealing with custom patches
when you apply to your live software?
Can you repeat it?
In regards to hashing,
how are you dealing with custom patches when you apply it?
So if you need to patch software you're using,
but you can't apply the patch upstream?
In the case of the...
Yeah, just in the case of the distro, or...?
It has a distro and a general response.
Well, yeah, the question is,
how do you deal with patched software, right,
when you apply a patch?
So...
But, I mean, you still have that hash, right?
Or is the question about naming...
So what's the best practice, I suppose?
Yeah, so if you're describing a patched artifact,
I mean, the hash, simply hash the thing
and you can use that downstream.
The problem comes when you're trying to define,
well, I'm using curl,
but I applied a few custom patches myself.
How do you name that?
And that becomes, like, a more complex question.
So internally, as I was saying with the integrity thing,
is you can still reference everything with the hashes, right?
Like, I'm talking about binary, this hash,
all down the stream.
But when you want to express it externally,
well, I guess that falls into the naming problem
and you have to think about where that thing is going to be used.
So if that is going to be a package part of a distribution
that you're doing,
you may define your own set of package URLs, for example.
Or if it's not going to be, you can make up the license,
but it falls more into the use case
of what you're trying to do with distributing the patched software.
So that's it. All right. Thank you.
Thank you very much.
Thank you.