1. Library
  2. Podcasts
  3. The Secure Developer
  4. Ep. #24, Application Security with Omer Levi Hevroni
The Secure Developer
38 MIN

Ep. #24, Application Security with Omer Levi Hevroni

light mode
about the episode

In episode 24 of The Secure Developer, Guy is joined by Omer Levi Hevroni,Ā DevSecOps Engineer at Soluto, to discuss application security, OWASP, security ā€˜mavens,’ and more.

Omer Levi Hevroni has beenĀ coding since the 4th grade, when his father taught him BASIC (Beginner’s All-purpose Symbolic Instruction Code). Today, he’sĀ doing AppSec/DevSecOps at Soluto. He is also an active open source contributor, OWASP Member, and OWASPGlue project leader.

From Developer to DevSecOps
The Security Mavens Program
Embedding Security in the Pipeline
Static and Dynamic Analysis
Packages and Containers
Kubernetes and Infrastructure as Code
OWASP Glue and Rolling Out Tools
Make Security Usable

transcript

Omer Levi Hevroni: If you have a tool that just generates a report, you cannot assume that a developer will come in the morning and say, "Hey, you have a report here. It might be interesting to open it and see it." And I think this is something that you should try to think about it all the time on how to make security usability and not just security for security. It's hard, it's not simple, but this is where we should go.

Everyone likes to use packages, and packages is great, but also can come with non-security vulnerabilities, and you want to make sure you scan your packages to make sure it doesn't contain vulnerabilities that everyone knows about. For example, Equifax.

Guy Podjarny: Hi, I'm Guy Podjarny, CEO and co-founder of Snyk. And you're listening to The Secure Developer, a podcast about security for developers, covering security tools and practices you can and should adopt into your development workflow.

The Secure Developer is brought to you by Heavybit, a program dedicated to helping startups take their developer products to market. For more information, visit heavybit.com. If you're interested in being a guest on this show, or if you would like to suggest a topic for us to discuss, find us on Twitter, @thesecuredev.

So welcome back to the show, everybody. Glad to have you back. Today we have with us Omer Levi Hevroni, who is a DevSecOps engineer at Soluto. Welcome to the show, Omer.

Omer: Hi, thank you for having me.

From Developer to DevSecOps

Guy: So there's a lot of interesting topics for us to talk about, Omer, but before I dive in, why don't you start by just telling us a little bit about yourself, what you do, and maybe a little bit of how you got here, how you got into security, into this specific role?

Omer: So hi, as Guy said, my name is Omer. For the past three and a half years I'm working at Soluto, and for the past two years I'm doing mainly AppSec, DevSecOps at Soluto. I started as a developer and did a shift into AppSec. Something that has an inside Soluto. I think we will talk about it a bit later.

So this is a bit about Soluto, just in case you didn't hear about Soluto. Soluto is an Israeli-based company, four years ago purchased by Asurion, a US company. And our mission is to help people with the technology devices they own or the devices they have at home and how to get the most out of them. So this is Soluto, this is me.

I like to think about my job as helping the developers to ship more quality product, which is main security, but not only, because I'm part of the DevOps team and this is what we are trying to do. So security, but also other things.

And finally, but also very important, is OWASP. I'm in love with OWASP, involved in many projects and leading one of the OWASP projects we called OWASP Glue. Glue is a tool that is the integration of security tools into the CI/CD pipelines. So this is me, this is OWASP.

Guy: Yeah. And I think OWASP, if you're not familiar with it, is the Open Web Application Security Project. We don't know, probably most of our listeners know what it is, but it's sort of, I guess, a community and a gathering of all sorts of projects and initiatives that relate to security tooling, security knowledge, application security, more specifically.

Omer: Yeah, if you're not familiar with OWASP, check out the website. It's a really good source to getting started with security and find resources and all that.

Guy: How is it structured indeed inside Soluto? So we're gonna dig in a little bit into Soluto and security, but you mentioned you're a part of the DevOps teams and you also mentioned you're DevSecOps. How does it work? What does the team look like?

Omer: So Soluto worked with journey teams, which means that teams are built according to business values. So for example, we have a team that is responsible for all the first few days of the user within the applications. It's called First Experience. And the team can contain developers, product, UX, content writers, whatever the team needs to be fully operative.

And teams are very independent. And they can decide whatever technologies they need, and we work a lot with microservices, so each team develops its own microservices, and if they need something from other teams, they just add code. So this is all the journey teams.

I'm part of a bit different team, which called the DevOps team. The DevOps team is, it's a bit non-traditional to have DevOps team, and we know it, so we try to find the right spot to have a DevOps team, which will do things like operating Kubernetes cluster so the rest of the teams can use it. And on the other hand, not be the ops team, but inspire the entire company to build more quality product. And I think AppSec is a really good fit into this team because it's another part of building more quality product.

So this is about how Soluto operates. And it means that the developers, and actually everyone at Soluto, has a lot of freedom and a lot of responsibility and a lot of power to do whatever they want and to get us to a better place.

Guy: Yeah, I think there's a lot of logic to it. I think there's a difference between perceiving or creating a DevOps team in the notion that you're still not sharing ops responsibility with the team, but rather suddenly this team is the one that needs to be DevOps, sometimes goes against the very premise of what DevOps is about.

But I think, title aside, there's a lot of sense in saying that there's a team inside the company, and we see this a lot, and we do this a little bit at Snyk, whose customer is the internal developer, kind of the prospect is there and kind of the team's goal is to indeed make that. And to an extent, SRE is also like the service, the reliability engineer, kind of that concept. Again, a lot of different tweaks and different elements to it.

But what I really like is that security is a part of that.

You deal with security, you focus on security, you work on security, but you're not like some disparate, independent security team. You work as the same part that empowers the developers to get the, as you said it, right, better quality, and security be an aspect of that done.

And just, I guess, like one more bit of context on it. So Soluto is a specific company that is a part of Asurion?

Omer: Yeah, Asurion is a very big insurance company located in the United States. Asurion focused a lot on insurance. That's what they did in the past and they are still doing.

And we are part of Asurion R&D. So Asurion have a lot of other R&Ds all around the globe. So we are part of them.

The Security Mavens Program

Guy: Got it. And we talked about this a little bit before, how do you work from a security perspective? You gave us the context of Soluto. How do you work? Like your sort of DevOps, the security practices that you do, how does that interact with sort of the broader security perspective from Asurion?

Omer: So this is what I started with. I started at Soluto as a developer and I think it was two years ago. Yeah, it was more than two years ago. Asurion started initiative called, it comes from Asurion Security. They understood that they have more and more developers all around the world and they can no longer maintain security from sitting in Nashville or in San Mateo or wherever they're sitting, influencing the entire R&D all over the globe.

So they started a program called the Security Mavens, which is basically like other companies called the security champions. It's basically the same thing, which is, instead of going and hire external security experts in each R&D and starting to embed them into the R&D, they chose developers from all around the globe, give them security education.

For example, I did a SANS course, SANS pen testing course. It was one week of a course and then a test. So we did this course and we started to work together as Mavens. We are now a group, we have a Slack channel, we're talking a lot. And this is how I get into all this security, AppSec world.

Currently here at Tel Aviv we have two Mavens, and we started to add more because we understand we need more. So this is how it's all started. We are now interacting with, there is someone in Asurion security team that is responsible on the Mavens. So we are communicating a lot with him for guidance and help and to learn more of what we want.

And here at Tel Aviv, like all other people, have a lot of freedom to add things and try to think about new things that can improve the security here.

Guy: Yep. The name's catchy. Just roll with it.

Omer: You know that the source of the word Maven is Yiddish, actually.

Guy: Oh, I did not know.

Omer: Yeah, it's come from the word mevin, which is in Hebrew "know." It's really funny.

Guy: Yeah, no, I didn't know that. You know that, I guess, gives it history. Yet another reason to have two Mavens in the Tel Aviv team.

So do the Mavens typically have, as a part of their day job, like, is your day job security, or is your day job a bunch of other things and security, and you're just sort of passionate and therefore find yourself doing security? And I guess, how is that similar or different to other Mavens across Asurion?

Omer: That's a good question. One of the main challenges of being a Maven, and I've seen that with the entire Mavens, is that you need to be a Maven beside of your regular day job. I very fast understood that this is what I do want to do full-time, and I think there are not a lot of Mavens who are doing it full-time.

And I did it full-time for the one and a half year and then I joined the DevOps team. So now I do a part of a regular DevOps task, like building Kubernetes task, DevOps stuff like that, and a security task, and start try to combine them, but it's definitely very, very hard to find the right spot between doing your regular job and doing the Maven stuff because it's not easy.

You have tasks that you need to complete and you need to somehow think about security things. So this is a challenge of being a Maven. Yeah. And I had lucky to not have it.

Guy: Yeah. And I guess, but it's the versatility also of the program, where is relevant, then people would have that as a full-time job versus not.

Omer: Yeah.

Guy: Very cool. So I think, like, the Maven program, I want to spend a couple more minutes on that one still, just because it sounds like it's working well and I think it's a program that many people try to do. Can you tell a little bit about, like, how is knowledge shared within the Mavens? Like you mentioned the Slack channel internally, what other good tooling or methodologies work to sort of share information between Mavens?

Omer: So we have a few virtual meetings, one or two a year. We also try to meet like in big conference. For example, in two months some of us are going to be at AppSec California and going to give a talk there. So we will be there, we will talk together, hang out.

Last year we did an internal conf for all the Mavens right after AppSec California, and we might do it again this year, or for example do it at DEF CON, Black Hat USA. So this is an example as to where we can meet, share ideas, and learn from what others are doing.

So sharing is hard, but we try to do it as much as we can. And different Mavens have different challenges, so this is also interesting to see what they face, what we are facing. And folks, there is someone from Asurion security team who is responsible for all the Mavens. So he also help us, like to say, okay, they face the issue you are facing, maybe you should talk with them.

Guy: Right.

Omer: So we do the coordination.

Guy: Yeah, it makes sense. So basically, a component of it is just natural social interactions. You're on the Slack meeting. You meet up, you naturally go to some sort of the same events, and then you meet up and share knowledge there. And some of it is a little bit more coordinated by the person in the central security team whose job it is to make this program successful.

Omer: Part of his job, yeah.

Guy: Or part of his job.

Omer: Yeah, his main job is, he's responsible for application security, so it makes sense that Mavens is part of his job.

Guy: It's one of his primary tools, I guess, or sort of primary means of succeeding that. Yeah. Cool. So thanks for sharing that.

Embedding Security in the Pipeline

And indeed, let's maybe veer off from the broader program into, like, practically speaking. So can I ask you to describe a little bit how is security embedded today? You work in this very modern, it sounds like a very modern surrounding, and power teams, they run it. You have your sort of continuous deployment pipelines, use Kubernetes, quite clearly. How is security embedded into it in the sort of practical day-to-day?

Omer: So I already mentioned that we have very independent teams and we don't have one central mechanism that controls what teams are doing and like say to teams, okay, you can't do that or you need to do it that way. And this is something that is very challenging as a Maven, to come and engage the developers. Help them understand why they need the security, not only developers but also product managers and everyone else.

This is the main challenge I'm facing for the last two years, and we are trying to do a few things to handle it. It's still a challenge. We want to succeed solving it.

But we try different things. For example, I'm doing a monthly security awareness session, each time on a different topic, trying to encourage developers during the session themselves, so they can learn about something. We also try to do threat modeling workshop when we do like a quick overview of what is threat modeling and give them a hands-on experience.

And of course a CI/CD, where we try to integrate the static analysis tools or tools that do dynamic analysis with OWASP ZAP. Package scanning, of course, Snyk. But this is also a place where things can get really complex because it's not enough to have tools. You need someone to integrate them into the pipeline.

So we need somehow make the DLC product understand that, for example, now, when they create a new project, they should spend some time on adding Snyk to the project and look on Snyk finding and fix them if they need, because it's requires some time and they need to want to do it. Otherwise they will just ignore it and the tool will not be helpful. So it's not a simple task.

Guy: Indeed. So I guess actually, like, digging into that, and I think you've already veered a little bit, you've actually written a good post about this that just summarizes a bunch of these tools. So maybe let's get detailed a bit and just say, hey, across these tools, for the different categories, what's your view of the tools one should consider, the ones you use, and like the elements of them that help or hurt embedding them into that type of development process?

Omer: Yeah. So first I think that when talking about tools in general, the most important thing is that the tool must break the build.

I mean, if you have a tool that just generated a report, you cannot assume that a developer will come in the morning and say, hey, you have a report here. It might be interesting to open it and see it. No one will do it. I can say about myself.

We have a static analysis tool that just created a report in the build, and I was like, okay, there is a report there. I have no idea what is there, but I have other things.

So this is the most important thing. Break the build or it doesn't happen.

And this is why I'm so invested in Glue. A lot of time you can find great security tools, but when you try to integrate them into the pipeline, things get messy because the tools don't support the CI tool you were using. For example, they don't know how to output in a format that TeamCity know and love, or they don't have a good way to ignore false positive, which is also very important.

Like, you can break the build, but you need somehow for the developer to say, this is false positive, I want to ignore it. And Glue can help with that, and this is why I so much invested in this tool. For me it's the basic requirement from any security tool. If you don't do that, there is no meaning to adding the tool at all, beside having like a checkbook saying I'm running static analysis, which is also important.

Guy: I guess it's a tricky action. Like, on one hand I'm entirely with you, right? Which is, you have to be realistic with your expectations. The fact that you've provided information off-band, just like in some other repository, we're just not, nobody's gonna notice that you run it. So you have to kind of get real and break the build, or like get in line with the developers' actions, not expect them to kind of go off and read and work off a list that is stored somewhere else.

On the flip side, breaking the build is a pretty aggressive action. It's a sledgehammer.

So I guess what you're saying in that context is the security person should feel empowered to break the build, but to achieve that, you need to ensure that the developer has concrete actions they can take without waiting on that security person to move forward.

Omer: Yeah, this is what I said about engagement. For example, it's a lot of how we work, developers have full control and they can decide that a specific finding is a false positive. It's not something that they need to come and talk with me and I get an approvement.

So you need to understand that the pipeline is theirs, it's not yours.

And if you add a tool to their pipeline, you should respect that it's not your pipelines, and they should have the full ownership of the tool, they should have the full power of disabling it, marking something as false positive, or do whatever they want if the tool is not behaving.

So it's a good point, and this is something you should take into consideration. And again, this is why you must make sure that you talk with the devs and they want to edit, and they know what the tool is doing and the value it gave, which is not simple. Not simple at all.

Guy: So I guess, like, an interim solution between, like, it's in the build's textual output or whatever it is, or even in some other third-party tool's portfolio, and breaking the build, oftentimes what's being discussed is like log a Jira issue, right, or like get it into my issue management. Do you find that effective? Do you do any of that?

Omer: I think it's even more violent because, as I said, it's the team responsible to decide if they want to log in to file an issue. And it's their decision if they want to open an issue on GitHub, put something on Trello or whatever they want to do. It's the totality of decision. All I want to do is break the build and then let them, and Glue, Glue let you do that.

Glue basically let you say, I want to ignore it, I want to postpone it because I want to handle it like in two months, and then you can file an issue and take care of it later, and it's all coming from the same place. Let the developers all the information, then let them choose what action to take. But give them the power.

Guy: Yeah, it just has to be empowered.

And it's legitimate that on one hand breaking the build is hard action, on the other hand it's a transient action. So the build broke, you've done something, you went away.

Like if this was a false positive, there's never any like false record of it being an issue that you have to now acknowledge.

It's like you broke the build, you said it was a false positive, you ignored it accordingly, and you continue. While if it was logged as an issue, then suddenly it gets into like your metrics and those elements, and that might actually be more aggressive depending on how the team operates.

Omer: Yeah, and you take a decision for them that it's an issue they should look at.

Guy: Right.

Omer: And of course you can also put it as a GitHub check on a PR. For me it's the same, like if it's a check on PR or breaking the build, same thing.

Guy: It's about the same because it's in the pipeline. So yeah, I'm, like, at Snyk and in general, like myself, I feel like the commit status tests on pull requests are pretty happy medium between them, because on one hand they are very visible as an individual test, and on the other hand you can choose whether they're breaking or informational. Like, you can kind of make them so they're a little bit more flexible around allowing a team to decide whether this breaks or not, which you can do in the build as well. It's just the build is a little bit of this, like, one big unit.

The other aspect of it is that pull requests test a delta, right? They test a change between this change, while builds test a state.

So especially in the context where suddenly some new vulnerability can come from the outside, pull requests have some advantages there. But I agree, like, conceptually it's the same as what you're describing. It's just about putting in the pipeline.

Static and Dynamic Analysis

I love that in the blog you actually talk, just to get practical, because I believe kind of the listeners would like that, just sort of go through the specific classes of tools that you have. And maybe say a few words about how you treat them.

Omer: Yeah. What I try to do on the blog is going over different security tests that you can use, different kinds of tests that you can use to test the quality of your code. This is why I called it "Want to write a good code? Start using security tests." And I try to mention a few open source, free security tools that you can start using today.

So for example, I started with static analysis, and there are a lot of tools with a variant quality out of them, especially the commercial one, not all of them are good enough. And there is a nice tool by Microsoft called DevSkim. It's a really nice tool, and what I really like about it is the IDE integration.

There is an example on the blog post where you can see that by using DevSkim with Visual Studio Code, you can just with a few clicks fix the issue. Like, DevSkim can fix it for you. You don't need to think, you just need to click twice into places and issue is fixed.

And it's really, really powerful evolution of static analysis. Like, it's feeding you with a spoon, and you don't need to think, oh, I had an insecure URL, what I need to do? You can just click. Or I have a MD5, which is insecure, which has algorithm I need to choose?

It does the decision for you, and it's really nice. It's make it a lot more easier.

Guy: Very cool. DevSkim, right?

Omer: That's the DevSkim, yeah. By Microsoft. It has support for a lot of languages and some IDEs.

And another tool to notice is that it's very easy to write rules for DevSkim, which is not always the situation with all the static analysis. In DevSkim it's really simple, and you can even write test to it, which is amazing, because if you cannot customize the static analysis tool, you miss a lot of the power, and here you can do it and it's simple. So this is DevSkim.

Guy: Okay, very cool.

Omer: And the second thing is dynamic analysis, which is, if static analysis look on code, dynamic analysis try to look on live application and request and response and see what's going there. And here I mention OWASP ZAP, which is a security tool by OWASP. And you can use it to proxy your application, and it can point to various security issues in the app. Very nice, very powerful. You can check out to see how you can do it.

It's actually relatively simple to take existing black box or end-to-end tests and plug them to ZAP, so you can get dynamic security tests for free.

Guy: And how do you set up? So like static analysis, you look at the code, there's a question about scan times and the likes. Although it sounds like DevSkim is more about the IDE, so it's more like just inline. You don't put it in the build, but you

Omer: It has also both CLI and IDE.

Guy: Yeah. Okay. But for ZAP, one of the objections oftentimes to put black box testing, or dynamic, DAST testing, is that you also need to set up an environment, like you need to set up some system to run, and sort of the length of it. Like, what have you seen with ZAP? What do you recommend doing there around it?

Omer: So what we are doing here at Soluto, we have a lot of, we call it black box test, but some other places call it end-to-end test, which is a test where you run your API with Docker Compose, and then you send like HTTP requests to it and see how it reacts. So once you have such test, you can just proxy the request and response from the black box through ZAP, and then you get a full dynamic test without the need to have another environment and start mocking requests and responses.

And it is the entire solution, and of course if you have good coverage of the black box or end-to-end test, you will also have good coverage of the dynamic analysis. So it's very nice.

Guy: So it leverages, it builds on the invocations of inputs and things like that that your natural unit tests would invoke, and just extends them to introduce security tests, like manipulate, basically.

Omer: Yeah, leveraging the fact that we're already using something to send requests and response to the application. Yes.

Guy: Yeah, to an extent it sounds like the unit tests are the crawling phase, because a lot of these black box testing tools start by crawling the application to discover inputs and then continue to manipulate them in attack, and to an extent, what ZAP does is uses these existing tests as the crawling bit and then just goes on to the attack.

Omer: Yeah. And then you don't need to guess what URLs exist in the application. And again, you have good coverage because the dynamic end-to-end test usually try to cover as much as possible from the application.

Guy: Got it. And how much, like, what's your experience been around the duration over the time? Like, how much would that add to my build time if I introduced this type of thing?

Omer: Not a lot. The effect on the build time is relatively small. It's a bit of a challenge to add ZAP to existing tests. It's required not a lot of work. I try to make it as simple as possible, and there is a full guide linked on the blog, but it does require some effort and some changes to how you run your test, because you need to interfere with the request and response from the test to there.

Guy: Got it. Yeah. So there's some natural, like, you're gonna send some requests, you need to proxy some components.

Omer: Yeah, exactly.

Guy: Cool.

Packages and Containers

So we've got SAST and DAST, kind of the static and dynamic application security testing. What else do you do?

Omer: So to complete that, if we talk about our code, the next part is talking about the packages we are using. Like, everyone likes to use packages, and packages is great, but also can come with non-security vulnerabilities. After all, it's a code that someone else writes. And you want to make sure you scan your packages to make sure it doesn't contain vulnerabilities that everyone know about. For example, Equifax, which we all, I think

Guy: The infamous Struts vulnerabilities.

Omer: Yeah. It's always good to mention them, to make sure, or it's now even part of the OWASP Top 10. A9 is about using components with non-vulnerabilities.

So there are a lot of tools out there that can be used. I think the most mature one, which is also open source, is another tool by OWASP, OWASP Dependency-Track and Check. It has a really nice UI and it has support for some languages. But here the tricky part is, how do you know which packages contain vulnerabilities? And I think this is something you can talk a bit about more than me.

But this is part of the reason that if you can pay for a tool, Snyk might be a better option, because, and again this is something you can share more than me, they usually can detect issues that other packages didn't, due to some reasons.

So this is about packages, and here the hard part is how you need to upgrade, and this is another place where Snyk do a bit better job than other tools, really help you to fix the issue, upgrade to the right package. So this is about packages. Do you want to add something?

Guy: No, I appreciate the, I know, so it's great, and it's probably worth for the listeners to know that Omer has been a super helpful user as well in the world of Snyk, kind of giving us great insights and inputs around kind of making the tooling better and helping indeed, like, whether it's commenting and helping kind of build up, have a better vulnerability database, have sort of this better automated remediation, and those elements, helping kind of build up the container scanning capability that we launched earlier this year and those capabilities.

We're gonna put this aside a little bit, because I'm always a little bit uncomfortable with sort of the, not to make this podcast be a Snyk plug, but package scanning should absolutely be a part of that stack that you put together, and I hope Snyk ends up serving your needs, but you definitely should consider if you want OWASP Dependency-Check as a free open source tool there. Again, just evaluate your sort of database and usability there as compared to what commercial offerings like Snyk can do.

Omer: And both OWASP Dependency-Track and Snyk supporting notifications. So if you're using a package which is not vulnerable now, but, I don't know, in a month someone will report a vulnerability, both of the tools can send a notification to you.

And we integrated Snyk with Icinga. Icinga is a monitoring tool. If you're not familiar with Icinga, it's a fork of Nagios, so basically what you are going to do is, once someone add a Snyk, she can also add an alert. So if in the future a new vulnerability will be reported, the team will get an alert like any other alert, like any other production alert. "Hey, you have a new vulnerability, please fix it."

It's very nice, it's all using the existing flow of how we monitor our production. So it's something the developer is familiar with. And it's really important to use this notification, otherwise if you don't publish something, I don't know, for a month or so, you might miss new vulnerabilities.

Guy: Indeed.

Omer: Yeah. I think the next part is talking about Docker. Like, you need to put your code in something, and usually we're using Docker. And Docker images has pretty much the same images as packages, like there are a lot of packages installed there.

Here you have both issues. First is how you find all the packages. For example, there are some feature image which I will not mention who use curl to install things and not via normal package management, and you have the same problem as before, of to know which packages are vulnerable.

There are good free open source tools here, like Anchore Engine and Clair, which you can give certain Docker image and it scan it and return a report. And the report is, well, things can get messy because it's not very actionable. I give you one example of a vulnerability in libidn11. And this is something that you can't give to developer. Like, I myself have no idea what is libidn11, if I should fix it, and I will feel a bit scared to fix it.

And this is go back to what we talk about, that we need to engage developer and we need to help them fix the issue. We can't just talk about them, like, hey, your build is broken, you have all these issues, please fix them. No, it will not work. They just like, okay, I don't understand what's going on here. We need to help them fix it.

And here it's another case for Snyk doing a really good job, but I think we can keep talking about Snyk all the time. So I think it's the last time we mentioned Snyk. But this is another thing that you should consider when you choose a security tool.

See if the tool can help you understand what to do and not only what the issue is. Because it's very important.

Guy: Yeah, and I think that's consistent kind of throughout this conversation. We've been talking about the actionability, if you put it in the developer teams, like in the dev teams pipeline, it's their pipeline, they need to have that actionability and understand it.

If it's not realistic for them to have the time or the expertise, or if you do not empower them to do so, that tool is not gonna stay in the pipeline long. Right. Like, the best case scenario in those cases is that they will move it out. The worst case scenario is that they will just, like, agility would grind to a halt.

Omer: Yeah, exactly. And you also need to think about the amount of issues. For example, if you start reporting like hundred of issues, no one will take a look. No one can go on a list of, I don't know, more than fifty issues or so.

It's like impossible to ask, and something that is not reasonable. So you need to make sure that your expectation is reasonable and not just say, okay, I'm going to break the build and just throw about them every issue I can find.

And this is a serious issue with Docker scan now, where the open source does not give good solutions. And I hope it will improve in the future.

Kubernetes and Infrastructure as Code

And the last thing is Kubernetes file scan. If you're familiar with Kubernetes, Kubernetes is a way to run Docker containers in production, and you have files that control how your Docker is running in production. Now you can think about it, and again, please, dear Kubernetes user, don't nitpick me, but you can think about it like how you define your VM.

And you can understand from this description that you can do severe security issues. For example, you can mount the root file system, and then if the container is compromised, the attack surface is a lot bigger. There is actually only one tool that I was able to find out here, which called kubesec. The only problem is that it's an online service. You need to send all your file to an online service that's owned by a third party, and this is something I think most of enterprise will not feel comfortable to do.

Something to know, there are not a lot of good solutions here, and I hope we'll see more tools, or at least things that run only internally.

Guy: Yeah, absolutely. I guess to an extent, I like to think about this aspect as, if you have infrastructure as code, that code can have security flaws in it as well.

Basically, it's almost like the static analysis to your infrastructure as code. To say which bad security decisions have been made there.

Or even decisions that were not a problem at the time, but new knowledge coming to fore implies now that there's a better approach option.

Omer: And this is the same, is true for Terraform or for ARM template or whatever you're using. It's again going back to the developers and let them know. Like, say to them, hey, you open SSH port to the internet, maybe it's not a good idea.

Guy: Indeed.

Omer: So they now have an informed decision to make, and they don't just copy paste from somewhere and don't even know that there might be an issue here.

OWASP Glue and Rolling Out Tools

Guy: This is awesome, Omer. Like, a lot of info. I think this is very practical. Here's how I use, and we'll put the link to the blog post in the podcast notes for people to use.

How did you find when you kind of rolled out? This is, it's the other way around, right? Like, this is your learnings and understanding and working with OWASP Glue. I guess maybe two questions for you.

One is maybe just sort of give us a quick rundown on what OWASP Glue is and how it helps there. And second, just like, what was your experience about doing this inside Soluto? Like, if I wanted to sort of start with one of these, for instance, where would you start?

Omer: So I start with the Glue one because it's a lot easier. I already said before, Glue come to fill the gap of, a lot of security tools are not just good enough to run in the CI, for example. Again, they don't know to output in the format that your CI understands.

For example, they don't support GitHub check API. So Glue is like the bridge. It's like helping you glue your security tool into the CI/CD.

It has a few nice features which allow you to say, this is a false positive, I want to postpone it. It has a lot of format output, so you can output to file, CSV, Jira, or even TeamCity. Recently we added a way to dynamically add security tools. So if your security tool can output JSON, you can provide a file to Glue that say "Map this thing to this thing," and then you don't need even to add code to Glue if you want to add new security tool.

So this was Glue. The second question is a bit more tricky. We did a few iterations, and this is actually something I think to talk about somewhere in the future in the conference. I just need to build a full talk.

But we did a few iterations when we try to embed security tools into the pipeline, from, like, starting with a static analysis tool and just edit manually with, like, a script to all the builds all over Soluto. And this gave us the benefit of, static analysis is now running on all over the code, but it has a few downsides.

First, people just have a new thing in their pipeline which they don't always know what it's doing or why it's broken, and it makes them sometimes to just say, I don't know what it is and it's breaking my build, I'm ignoring it. So this is one issue.

The second issue was that when people creating new pipelines, they're not using the regular templates we are provided, they don't always had added the static analysis tool because again, they didn't know what it is, they didn't understand the value, and it was just there. So they don't end it. I was just needing to go over all the time and say, hey, you have a new pipeline, please edit. And it's not always happen. So this was the first iteration, which was not a great success.

With ZAP we tried a bit combined way, like it exists in some template, and if you create a project with this template you will get ZAP out of the box. But it's not existing all template, and the adoption is very low. And lastly is with Snyk, where we try like to just say to people, hey, edit, please. And again the adaptation is very slow, but the people who actually add it understand what it does.

So there is nothing I can say that work without issues, and it's all going back to the same part of talking with developers, talking with products, trying to understand, try to explain to the product. "Hey, you added a new feature. If you don't add this tool, here is what is up," and products are, it's also important for them to understand. So far it's working, but slowly.

And lastly is having champions, or Mavens. This is something we are trying to expand, the Mavens we have now in Soluto, and hopefully having more Mavens will allow us to get to more teams in Soluto and engage with them all.

Guy: Got it. Yeah. To sort of spread the kind of the local champions indeed. Very cool. Well, thanks a lot for all the info.

Make Security Usable

Before I kind of let you go here, I like to ask every guest, if you had one bit of security advice or a security pet peeve or some piece of knowledge that you'd want to share with a team looking to level up their security, or what to start doing, stop doing, what would that be?

Omer: So I think I mentioned here Avi, I'm going to mispronounce his next name, Avi Douglen. I'm sure I mispronounced his name, Asa Sector. He liked to say that if security is not usable, no one will use it, which is basically what we talk about all this session.

Make sure that you build things that are usable, that developers and users can use.

For example, don't add login page that is breaking usability.

And I think this is something that you should, I try to think about it all the time, on how to make security usability and not just security for security. It's hard, it's not simple, but this is the way we should go.

Guy: Yeah, I'm 100% with you. It's not easy, we don't do it. We're all lazy at the end of the day, and we all, not just about laziness, but like, we all have a million things to do. Omer, this has been great. Thanks a lot for coming onto the show.

Omer: Thank you very much for having me. It was very nice talking with you.

Guy: And thanks everybody for tuning in, and I hope you join us for the next one.

That's all we have time for today. If you'd like to come on as a guest on this show or want us to cover a specific topic, find us on Twitter, @thesecuredev. To learn more about Heavybit, browse to heavybit.com. You can find this podcast and many other great ones, as well as over a hundred videos about building developer tooling companies given by top experts in the field.

Subscribe to Heavybit Updates

You don’t have to build on your own. We help you stay ahead with the hottest resources, latest product updates, and top job opportunities from the community. Don’t miss out—subscribe now.