Skip to content
PodSubs
ShowsPeopleGuestsJobsNewsEvents
More
BlogPodCred
Menu
ShowsPeopleGuestsJobsNewsEventsBlogPodCredNetworksSign in
Join nowSign in
  • Shows
  • People
  • Jobs
  • News
  • More
    • Guests
    • Events
    • Blog
    • PodCred
    • Networks
    Join nowSign in

Jared's Technology Podcast Network

Jared's Technology Podcast Network artwork

Sans, episode 39: A webinar on vulnerabilities and AI

Apr 21, 20261 hr 5 minAudio
ShareXLinkedInFacebookWhatsAppEmail

Welcome to Sans, episode 39. This is not News Bites, we've not gotten that ready yet due to other commitments, but I feel that this is important. On Thursday, April 16th, 2026, Sans had a webcast about a very serious issue about AI and vulnerability findings. SANS Critical Advisory: BugBusters - AI Vulnerability Discovery Hype vs. Reality will be the web page you need to go to so that you can read about this. Apparently, Anthropic released and then pulled back a new version of Claude called Mythos which is more powerful than they thought. You don't want to miss this. If you want to watch the video, you may, because its on their Youtube channel. This is the link to the video which lasts an hour. According to the web page, SANS faculty and staff have 15 months of real-world experience using current AI models to discover vulnerabilities in penetration tests, finding critical flaws in code that human reviewers already cleared. On Thursday, we are putting that experience on camera so the community can see exactly what this looks like. That Thursday came and went, and they sent us an email to allow us to watch the web cast. The podcast is getting audio, while the link to the video is posted here for those who would rather have it. Thanks so much for listening, make it a great day! We'll be back with more Sans soon.

Audio and video play straight from the show's own hosting. PodSubs stores and serves no media.

Transcript

From the show. Tap a time to play from there.

Hey folks, welcome to another episode of SANS. I'm Jared Reimer. This time, we're not going to do a SANS News Bytes. At least, not yet. While we did release 38, we've not really had a lot of time to do any new News Bytes, even though several have come in. My 40 is right around the

corner, and I really think that that would be better to be read on the 40. Although I could read it on the 20, because there's really no formatting issues. We are running into issues with formatting 40 versus 20 on the... But we are going to get the Bored Podcast out through

a day in the life one way or the other. And I think I'm just going to use one file and call it good. But that's not what this podcast is for. What is this Sans News Bytes going to be about? It is going to be about a webcast which I was not able to attend anyhow, which Sans sent an email about. On April 16th, they had a webcast

about a very serious issue about AI and vulnerability findings. More specifically, you can go into a program find a vulnerability just as fast as a human can. Apparently, Anthropic released and

then pulled back a version of Claude called Mythos. And apparently, this can find vulnerabilities faster than your human counterparts. Was it actually publicly released? I'm not exactly 100 % sure.

I don't want to make that claim. But they made it. And people were testing it. So maybe it was meant to be pounded on? And then it was pulled back and not made available to the world as a general release because it was apparently too

powerful? Some of the staff that we've read names of, including Ed Skoudis, Chris Elgee, and Joshua Wright, are along in this one -hour webinar talking about this very issue. Why not give this a listen

and make sure that you are in the know? Yes, it's not a News Bites, but I think this is bigger than a bite. We will be back when we're able to get a Sands News Bites ready to go. And until

then, make it a great day. See you all soon. Stay safe, everybody. and welcome to this very

special session that we've prepared for you. Let's please bring up our first slide, if we could. This session is called SANS Critical Advisory, Bug Busters, AI Vulnerability Discovery, Hype vs. Reality. My name is Ed Skoudis. I'm the president of the SANS Technology Institute College. I also am a director for Cyber Ranges for SANS, and we've got some very important information to share with you. If we can move to the next slide, I'd like to introduce my co -presenters. As I mentioned, my name is Ed, but I'm joined today

by Chris Elgee, who is a SANS instructor. He also works with me on my team that does penetration testing. We also have Joshua Wright. who is a SANS fellow and the dean of students at our college. He also does penetration testing with me and our team of 16 penetration testers. So we are here to try to separate myth from reality regarding all that's been talked about in the press the last couple of weeks. I'm sure you've all seen that Anthropic has announced a new model, and they've released it in a very... a garden place

where certain companies that are their partners can get access to it. They call it Mythos. And of course, you all know this. But they announced about a dozen companies that were named partners to use Mythos up front in a initiative that they call Project Glasswing. They also announced that there's over 40 other companies that have access to Mythos to use it to try to understand its capabilities and what you can use it for. So why is this getting so much attention? According to Anthropic, this is a step function change

in the capability for advanced AI models to be able to find and automatically exploit vulnerabilities. So this has caused quite a hubbub in the industry. In fact, last week, Treasury Secretary Scott Besant and Federal Reserve Chair... Jerome Powell called an emergency meeting of all the major US banks to talk with them about how they're planning to deal with this kind of capability, not just in Anthropix release, but in other AI companies releases. Also, just this week, over

450 CISOs had a call a couple of days ago to discuss how they were working through this. Also, the UK government had an open letter yesterday talking about. the need for banks in the UK to be able to deal with this new capability that we're seeing. And the Bank of England sent a response to that, warning other banks. And the European Central Bank supervisors are planning on issuing some advice and consult, and also some questions for bankers in European Central Banks about this thing. Now, if you read about

this online, you'll see that some people are saying this is a huge deal. This is the vuln apocalypse. Oh, my goodness. This is terrible. Others are saying this is marketing hype. maybe by Anthropic itself, or maybe many of the large AI providers. In fact, if you look just yesterday, OpenAI responded by releasing a new version of their GPT model 5 .4, but one that's focused on cybersecurity. It's brand new, it was just announced yesterday, but people believe that they're going to lower some of the guardrails

so that that thing can do more deep analysis of finding security flaws so cyber defenders can defend against it. And then there's been other rumors that other AI vendors are going to release similar capabilities soon. So we've got Anthropic with its Mythos release that's in the hands of about 40 different companies. I've had three different friends of mine who have Mythos access reach out to me in just the last few days talking about how you can use it, how they're finding certain things with it, and

also they need some advice and counsel on how to use it. So it's been very much a dynamic changing situation here. The purpose of this webcast is to cut through the clutter by showing you what's possible now with existing models, and then discuss the implications for the industry. So I'm going to set the stage here, and then you're going to see actual hands -on video that Chris Elgy and my team have created over the last day to show you from vulnerability discovery. all the way through exploit creation and then launch

of the exploit at the target. So you can get the reality of what's possible with current models, which you're going to see is not mythos. It's what current models can do. Then Josh Wright is going to present to us and talk about what this means for the industry, what we all need to be aware of, and what our organizations need to do to continue to thrive and keep our systems secure in an age where mythos and other related AI models are available. So let's go to the next slide, please. So my team has been doing source

assisted penetration testing for 15 years. And if you're not familiar with what that is, that is where we'll have somebody who's having us do a pen test, give us the source code in advance and also give us access to the target environment. In source assisted pen testing, you don't really look at the source code up front. Instead, you do a traditional penetration test where you're trying to find vulnerabilities and you may find some sort of weird. situation inside the application or the system. And then you go and you look at the source code to try to determine where that weirdness is coming from. And you look at the

source code and get an idea of whether this thing is really exploitable or not. You then go back to the traditional pen test and try to figure out an exploit for it. The benefit of doing source -assisted pen testing has been that when you find the vulnerability, you can more rapidly determine if it's really a significant vulnerability. You can more easily exploit it. And then you can tell whoever's getting the pen test exactly the module and maybe the line of code where the vulnerability is. That's a status quo. We've been doing it 15 years or more. But for the past 15 months, my team has been doing AI enabled

source assisted pen testing. And this is a very different workflow from traditional source assisted pen testing. With AI enabled source assisted pen testing, you start with the source code and you have an AI tool go through that source code. as an agent that you intelligently interact with to find potential flaws. You then need to help weed out hallucinations, false positives, et cetera, so you can figure out what the real flaws are. You then have the AI find those flaws, create potential exploits for them, and then you launch

them at the target system and refine them to see if you get actual exploitation of the system. It's a very different workflow, and it's super efficient. In using this workflow for the last 15 months, we've uncovered some major findings, things that we have pen tested year after year after year, or other humans have pen tested. And these are brand new findings. Like sometimes my team will do a pen test that we did the year before or the year before or the year before. And we had a really great human pen tester or multiple work on it. But then on day one of the pen test, we find five critical findings using

AI -enabled source -assisted pen testing. Because what this methodology can find is subtle flaws in obscure workflows. I'm talking like a workflow that doesn't make any sense. That said, if you click on the certain buttons or move the system in a certain way or execute certain commands, you can get the system into an unusual state that a normal workflow wouldn't touch. But then within that, there is an exploit or vulnerability path that you can then use. And we're seeing things like authentication bypass here, authorization flaws. BOLA vulnerabilities, broken object level

access, IDOR flaws, insecure direct object reference, cross -tenant access, race conditions, all of these different things. So my team's been doing this for 14 months. And now we're seeing the acceleration of the capabilities of the models. And that's what's gotten the big hubbub is all these models getting so much better. And we do believe this will change our industry. It's not the end of the world, but it is a significant sea change. So Chris Elgy is going to demonstrate to you the discovery process, the exploit process using current models. And then Josh Wright is

going to talk about what this means for the industry and what we all need to start doing. So let me turn it over to Chris Elgy. Chris, please take it away. Thanks, Ed. Yeah, so let's look. through exactly what Ed just described, right? This is code -first pen testing with current models. And I think we'd be remiss if we didn't first talk about legal concerns. It's easy to do the wrong thing here, right? It's easy to be on an engagement and take all of somebody else's source code and shove it up into a model you don't control and violate some terms of service here or are NDAs of the clients. So the first thing we want

to make sure is that we have permission to share these with models. And if not, maybe it's something we can test locally, right? We don't get as much mileage out of local models. even with strong hardware, but that's still generally the same kind of flow. And throughout this whole section here, picture whatever the underlying model, it could be anything, right? It could be Gemini, Codex. It's not super important because it's the workflow we're really trying to focus on here. And one of the things that is a limitation in all models is context window. There's only so much... space that the model can use to think,

if I can use the term think, right? Not really thinking, but there's only so much that can be processed at once. And that includes the system prompt. It includes the code you're feeding it, the prompts you're giving it. It also includes... all the output tokens. So there's a context window measured in tokens because I guess anything to avoid the metric system. And we have to manage that throughout the process. So a lot of what we'll go through in the next few slides is just managing context window and trying to keep it focused on what we actually need. Sorry, I got excited. I keep hitting my microphone. The next one is that kind of a truism here where... Most

of the vulnerabilities happen usually in a small proportion of the code. We're generally less interested in things like cascading style sheets. We're more interested in authorization flows or in coupon redemption processes or OAuth. Those are the kind of things where the bones tend to live. And we'll have the model focus in on exactly what we're looking at. The next one, if you've used LLMs at all, you know they make mistakes. They have issues. They hallucinate. They tell you how smart you are and what a great idea you've come up with. And that bleeds into this significantly,

right? We can have it ask for volumes, and it'll come back and say, yes, here's an easily exploitable critical vulnerability that just doesn't exist. So we'll use our prompting to guide that in and then use subsequent prompts to validate and prove things out to make sure that we're getting actual results. And then, of course, we'll exploit it ourselves. ourselves to validate, because that's what pen testing is, right? We're not just running a vuln scanner and telling them that the sky is falling. We're actually going to prove things out through exploitation. But the upside is here, models are really good at some things. For example,

creating tools. If you are trying to rip through some code and you just needed to look for certain things like... LLM is there for you. If you need to build out a proof of concept, or one thing we'll do here in the demo is build out a test harness. We'll take a slice of the code that we're going to be looking at and just rebuild that as a local application we can test against. That's something the LLMs are great at building on the fly. Another thing they're great at is searching for patterns, looking for things like specific authorization flows. And, oh, here's a place where we're filtering input a certain

way and it's flawed. Where else do we filter input in that same manner? Where else can we find this pattern? So we'll use the LLMs to do that. Also, following code, right? Code can be a mess. We're going to look here at a code platform that's about half a gig of code and well over a million lines of code. And humans can follow those code trails, but it takes us a long time. We have to pick through, and LMs are good at following that, finding all the dependencies and child functions and everything. And lastly, iterating. We humans get bored. right we we get

sick of looking back at that same block of code again we don't want to test it one more time but the llm doesn't mind it'll iterate through as many times as you want and and that's great we'll leverage it to do that hey chris can i add something in real quick so hey we'd love to hear from you some people are already typing into the chat now if you have specific questions we've set aside time at the end for q a so type those questions in there we have the sans team pulling out those questions and they're sending to us and we'll do a whole q a with me asking questions of of chris and josh at the end Also, I want to point out that we wrote a brand new

course. It's a two -day course at SANS that covers the methodology Chris is going to introduce next. So what you're about to see is actually directly from the course, although this is a separate example from what's in the course materials. So Chris, back to you. Yeah, thanks, Ed. And I think it's... It's important to note that the hype right now is about a specific model, but this workflow applies to whichever model you're using. You might be able to, with a local LLM, rip through 500 lines of code of something you wrote and have no problems. And then maybe with

a current Opus or Gemini or whatever, you can get through 100 ,000 lines. But either way, when you get to sufficient size, the... the technique matters. At any size, the technique matters. So these are the steps we'll walk through. The first is to map the repository or the code repo. We want to generate basically a summary, a table of contents of what the code looks like. And this is a model that the LLM will use throughout just to reference where things are and where it can find specific functions in code. Next is to find that 20%, right? It's a relatively

small proportion of code that has most of the vault. So we want to zoom in on those. And we'll do this here in the upcoming slides. And then as we progress, we're going to keep narrowing and narrowing the context because, again, the model, whichever model, they can only process so much data at once. There's only so much code that can be run through at a given time. Once we're there and we think we're maybe getting close to something that's significant, then we have it. We work with it to find vulnerabilities. And really, again, with this constrained context here, hopefully we're finding things that are

real and not just hallucinated. At this point, when we've got a good candidate vulnerability, that's when we can create the test harness. That's when we can take pieces of the code and run it locally and test it quickly and many hundreds of times over. If it's a small code base, maybe you run the whole thing. But in our example here, We're working with a large code base, so we do want that test harness. And then here, exploit dev, right? The test harness is up, so we can let it rip through and create a thing. And then lastly, every pen tester's favorite part of the engagement, of course, is writing the report. It won't do it all for you. I mean, it'll spit

something out for sure. We still want to massage it a bit ourselves, but it gets you at least 80 % of the way there. And really, that's the truth with all of this. It is artificial intelligence. You do have to bring your actual intelligence to the game here. That's part of the show. So the code base we're looking at here is something called Data Ease. And suffice it to say, it's large. Like I said, about half a gig, 1 .7 million lines. And there's a language issue here, right? Looking at this, I know I'm going to have trouble because, forgive my cursor here, Java. Ew, right?

I move Java in view. So there's that. Also, Japanese. I don't speak Japanese. I wish I did. That's going to be a problem for me, but not for the LLM. So a great code base to work with here. And I think it's worth pointing out, too, that we've got folks on our teams like Chris Davis and Evan Booth that have really done a lot to develop these methods. And I know other people in parallel have developed similar methods, but I do want to give them a specific shout out. And Evan wrote through data ease for us here. So let's walk through what we found. Chris LG, so can you, what is data ease? What does it do?

This is a real thing that we found online? Yeah, no, that's a great question. Yeah. So this is basically a CMS, a content management system. And it had, oh, this is very important to mention. Thanks. You reminded me. The bugs we're going to walk through here were found about a year ago and disclosed and patched. In the course of testing this. Evan found some unpatched bugs, reported them responsibly. But we're not dropping ODE on anybody here. These are bugs that already exist and have been patched. Thank you, Josh.

So here we are. And we'll just roll through. We're not doing this live because LLMs are non -deterministic by nature. So we didn't want any surprises today. So this is all pre -done. And the first step here is just asking the system. to focus on what we're looking at. Hey, we're looking at this version of Data East. Please confirm. And that's it. And it comes back with a reasonable response. Yes, this is the code I'm looking at. So now we know we're about ready to go. So then we begin the mapping. And here, this one runs longer, so I'm going to skip through

it because we don't want to wait five minutes for it. But here we're saying, great. go through the repository go through the repo and look for everything write a map of everything so that so that you the lom can reference where things are so that as we start to focus in on potentially vulnerable areas you the lom know where they are so it churns and churns and churns and then toward the end here we get a couple of key output files you see those on the right one is a repository map and that's basically a flat text file that it can reference you can reference and then also

we get here some attack surface notes. So you might notice as you try this, the system may try to get ahead of you. And one of the things we manage, and to Ed's note about 543, one of the things we try to manage in that class specifically is keeping the system from getting ahead of us. It's very helpful. It really wants to lean forward and find you the vulnerabilities before it's really gotten a narrow enough context to do a great job at that. So anyway, we have these two outputs here, the repo map, attack surface notes, and those notes look... like this. So standard

markdown. It's fairly human readable. This isn't XML, right? We can more or less read this. But more importantly, the LLM can reference it as well. All right, so then now that we've got this all mapped out and we've got some ideas here, we've got different functions. It's already identified different workflows. We might want to zoom in on. We can say, all right, give me a short list. You now see all these functions. I don't want to do exploit development yet, but just find some things that are worth. paying more attention to. And again, with a smaller repo, you could

probably do this in fewer prompts, but this is significant, right? 1 .7 million lines. So we need to do some culling here and some zooming in. Again, we'll skip ahead a bit. And Chris, can I add one point to this? While Chris mentioned that this is a vulnerability that was disclosed a year ago and patched, when we built this demo that Chris is doing for you, we made sure that the system had no information about that vulnerability. It is discovering it uniquely here in this session run. But at the same time, we didn't want to drop a zero day on somebody's head here and be irresponsible in this session. So that's why

we purposely re -found a vulnerability that had already been found and already been patched so we could demonstrate that to you. But as Chris pointed out, it found a bunch of other vulnerabilities, too. But that is an exercise to the reader. We're the good hackers. We're the nice hackers, right? Try to be. Hopefully. All right. So what we get out of this here is another markdown file, candidate matrix. And this is like this. So more markdown. giving some potential areas to focus on. So you can see it marks some as primary candidates.

It has some held, some that are maybe less likely to be fruitful for us. Note that with this step and with all the steps, your mileage will vary. You can use the same model, the same code, the same prompt and get a different response, but you can see where we're going, right? You can see where we're narrowing in on things that we can test and getting closer and closer with each prompt, focusing that context window. So here with that candidate matrix now, we can say, all right, I want to pick this particular save validate path. And why that one? I don't know. It looked

good. I thought there might be something there. Or maybe the LLM recommended it as most likely. But it seems like a good thing to test. And what's great about this is it's really helping us save time. This is stuff that we could, given enough time, find without the model itself. but we get bored and we move on, right? We're always limited as pen testers by the amount of time we have to spend. So this is just helping us go a lot quicker. So we'll start with this function and we'll let it run through, again, skipping some of the sausage making there. And it's gone through this function and now it has a good understanding

of how the save validate process works in the code and comes back with focus context. So with each of these, I'm not bringing the full context forward, right? I'm not bringing all the code I looked at at first to make the map and then the full map and all those things. Each time I'm bringing it in tighter so that now as I go forward, I can begin with this focus context. And it tells it, you can see here on the screen, hey, here's a function and here are some dependencies that it requires that feed into this. And here's where it goes from there next in data processing. And again, just zooming in tighter and tighter

on what we're hoping to find for vulnerabilities. So there on the right now, we see we have that focus context. That's our input. So great. LLM, I want you to go ahead and read the code there and just see what you see, right? So we've got a nice focus window here. Maybe we find something, maybe we don't. Spoiler, we do. But again, something that's already been patched. So it goes through and just looks at all these paths and just does a lot of the hard work that we either don't have time for or maybe don't have patience for. maybe

it's java and i just i just don't want to right but it's going to go and do all the analysis and then uh what it comes back with now are some some good notes so on the right hand side you see it's a verification notes here's some stuff that looks bad and here's why um here's how it might get patched here's here's a thing that might be a finding and we're not really at the end yet we're not reporting but we're getting closer to it You know, Chris, there's one thing I really like about this, just the layout of the screen. You see everything that the agent's doing on the left -hand side. The artifacts appear dynamically. I don't know if people saw that. They just kind of pop up as it creates them so

that then we can inspect them. But also it's a little more subtle. On the top of the screen, you can see the different tabs here. That is the actual methodology from this new SANS course, SEC 543. So right now we're in zero to vulnerability. Next is going to be component isolation and so forth. So you could see the methodology right there in the tabs. Absolutely. So with this now, we'll look at one of those markdown files and here's verification notes. So it's starting to describe not just the function itself, but really what pieces of code are going to be an issue

and what the technical analysis of what the flaw is itself. So we're really getting close at this point, but just step by step, zooming in deeper and deeper. So with those notes as an input, then we say, all right, I'd like to start hammering this. I want to try to prove out a vulnerability. So go ahead and create a test harness. So take that code, that 1 .7 million lines, and pull just the pieces you need. Build me some tool that will allow me to simulate this vulnerable process. And then we can build our exploit. So

it goes and builds. And again, something a human could do. I could not do this in one minute. There's just no realistic way. So it does for us. And here's just a snippet of the top of the code there. Built it in Python, not Java, okay? And gives us something we can work with. It'll run a local host on a high port. That's great. So this then I can test or I can ask the machine to test for us. So now with that up and running, I ask the LLM to go and do it, right? Exploit

this thing. that we both have come to the conclusion may be vulnerable and off it goes. So notice too that part of the problem there, don't over -claim. I want you to prove this thing out. Don't just say it's critical, it's bad. I want you to specifically show that it works. And it may still hallucinate. That's always a risk here with these systems. And that's why we, of course, bring the human actual intelligence here along with the AI. So it runs through and then, great, it's coming here with some JSON output. So it's bringing to the table here what it's saying is proof of an actual vulnerability, that it has

exploited it. And great, that's what I want. So what we've got next is... Show me, right? It's show me time. Let's see what this actually looks like. So here on the right, we have our test harness. This is a mock -up of the critical portion of data ease. And on the left, we're going to be ready to run our test exploit. So on the right -hand side, first what we do is we try to go to a page that doesn't exist. So this is basically a 404 error. This page does not exist. The SEC 543 RCE. So we get an error

page. On the left now, we run the exploit and we write to the database, or we write to the web root. This shouldn't be possible. We shouldn't, as an unauthenticated user, be able to do this. But we run the exploit, go back to the web browser, reload, and here we are. We've just written this here. And for those who might miss the subtlety here, we've popped calc, if you will. This is kind of a classic proof of an exploit. In a Windows system, you make the calculator pop up, and we've done that here. So again, a nod to the creativity of our own Evan Booth. So great, that's it. I'm

done, right? Almost, right? I've still got to write the report. So at this point, I asked the system to do that. And when we do this, when we do pen testing, we have a format that we like to write in. And it's not in Markdown, it's in ASCII Doctor. And we like to structure the information in a specific way. So that could be another input of here's a sample finding, here's a structure of what we want. But it takes that plus the vulnerability it's built and all the information it has about this particular issue and then writes something for us. I always need some human massaging here, but here it is. So rendered from Markdown, we

can see it's got an executive summary. It's got CVSS score of 9 .6. Maybe that's legit. Maybe it's crazy. But I mean, if I can write to the web route without authentication, that's probably an okay score. And then on it goes. So that is end -to -end, starting with source code and ending with a validated volume and report. Very good. Thank you, Chris. We appreciate that. Questions are coming in. They're great. You know, one of the questions is, you know, are you finding zero days with this? And the answer is yes. These are brand new vulnerabilities that no one's seen

before in the code bases that we're analyzing. But while they are zero days in that they were unknown before and there's no patch yet available, although the LLM can help with a patch. These are not brand new classes of vulnerabilities. You know, I had listed earlier IDOR, BOLA, race conditions, et cetera. You know, somebody said, how many new found vulnerabilities are novel zero days? Well, there's zero days in that there's, they've never even seen before, but they are in a class of vulnerabilities that are well -known and well -understood. And the LLM understands that as well and can speak to us about those

kinds of things. So it was a great question. I wanted to kind of address that right now up front. There's also some questions people are asking commonly about. what model was used for this um the point is there's several models and i talk with my friends who have access to Mythos about other models and how they're comparing that to, say, Claude Opus. By the way, I heard from Josh this morning that Claude just dropped a new Opus model yesterday or today, 5 .7, I think it is. Yeah, whatever. I can't even keep track of it, 4 .7. But the models that you're seeing and that LG just demonstrated are current

existing models. Our team is using Gemini a lot. We're using Codex a lot. We're using Opus a lot. Chris, did you care to share what the model was that you were just relying on? on there? Yeah. So this was primarily GPT -5 -4, although Evan had to use some Opus 4 -6 as well to do some of the validation because you run into issues, right? The non -determinism, maybe it refuses to do a task for you at a certain time. So a couple of different models went into this. Yeah. And any workflow that you create that uses AI,

this is a principle I've been talking with a lot of people about, needs to have the ability to seamlessly change out the underlying model because models... sometimes go crazy they get stupid that you run out of tokens because you spent more than you expected like uber did it was announced the other day they spent their entire yearly allocation in tokens by april um so so you need to have the ability to dynamically change the underlying model uh or else you might get yourself into a you know a blocking situation okay so so chris thank you for demonstrating

that to us very interesting really great workflow notice how different it is from traditional pen testing But what does this mean for the industry? We want to cut through the hype and focus on what do we need to know as security practitioners, as security leaders, about where this is headed, what comes next, and what do we need to do? And I can think of nobody better to share that with us than Joshua Wright. Thank you, Ed. Thank you, Chris, for going through all that. Thanks, everybody, for joining us here today. So I want to tell you a story about my Monday morning. Monday morning,

I'm reading the Anthropic report for the Mythos preview that's linked here, and I came across this couple of sentences here where Anthropic is saying that the last 20 years in cybersecurity have been relatively stable from a security perspective, but that large language models are going to identify and exploit vulnerabilities, and that's going to seriously upend this. tenuous equilibrium. And I'm thinking about this and I'm thinking,

whose version of relatively stable are we talking about? And I'm thinking about supply chain vulnerabilities, I'm thinking about zero days, I'm thinking about all the attacks that were constantly firefighting. Ed calls me up and I'm talking to Ed and I say, can you believe that they said this? And he's like, yeah, I think it's completely accurate. And I'm like, what? Ed was a little bit farther ahead of me on this topic. I hadn't quite processed it yet. But Ed was really right. And although

it seems like things are on fire a lot and we're constantly trying to deal with vulnerabilities and deal with patching and things like that, you know, I think that if we reflect back and look back, things have been relatively stable from a cybersecurity perspective. for a good many years. I've been in cybersecurity long enough to remember before Microsoft Patch Tuesday and how things used to be distributed all over the

place instead of maybe three zero days a week that we're dealing with. Although we have a lot of problems in cybersecurity in our industry, I think that we have been in a period of relative stability. And I think that when we look back maybe three, five, ten years from now, we'll look back and think, wasn't that nice? Wasn't the first half of the 2020s, wasn't 2025 nice?

Things seemed like it was so much simpler back then. And I think here's the important thing that we need to take away. AI is going to be asymmetrically advantageous to attackers. I don't mean that there's no opportunity for defenders to use AI better, because I think that's true. But I think right now, the advantage is really in the attacker's court. And I think Anthropic coming out, people are saying, you know, is this a PR stunt? Is it really groundbreaking? My answer

is, can't it be both? Can't it be all of those things? I think that we are looking at a time when we are dramatically shifting. how we're going to have to deal with vulnerabilities and how we're going to have to deal with addressing not three new O days a week, but hundreds of O days per week or possibly even many more than that. And I think that the next several years are going to be a very difficult time for the cybersecurity industry and for a lot of us. Chris,

we can move on to the next slide here. So what do we do about this? Chris showed us a great demonstration about how at CounterHack we've been using AI models to identify vulnerabilities with source -assisted pen testing. And I think we're starting to see attackers use this as well, not just in identifying vulnerabilities, but in weaponizing a lot of these vulnerabilities. And if you look at some of the more recent supply chain attacks and you see the kind of processes and the kind of techniques and you look at the

timing that adversaries are using, I think that... It is pointing to the idea that attackers are using AI more and more for adversarial attacks, not just finding vulnerabilities, but coordinating distribution, creating frameworks to deliver that, creating believable environments to duke people into doing things that might not have done without a really rich environment making them think that everything is just normal. And I think we need to take action against this. did some brainstorming here and I came up with

a couple of recommendations here. I think we need to very carefully look at every step of patching. We kind of treat patching as we need to do better at patching. Okay. I think we need to not only do better at patching, we need to do much better at patching and not just at any single part of the patching process, at the creation of patches. The distribution of patches, the acquisition of patches, testing patches, deploying patches, validating patches as well. We need

to do better in all parts of our ecosystem. Some things we do patching really well on Chrome browsers. They do really good at patching things. We have Microsoft Office auto update. That does a pretty good job. But there's a whole slew of other areas where patching is very difficult, like. Mac systems needing to access a read -only portion of the operating system to be able to change a critical file to address a vulnerability. That kind of outage mechanism is hard to automate. And I think

this is not just an enterprise problem. This is a vendor problem too. I think in all parts of our industry, Apple, Microsoft, every vendor, cloud vendors, everybody needs to do much better at patching and very critically look at all the steps to figure out how we can accelerate. patching to stay in front of a lot of these vulnerabilities. I think as part of that, we need to really reconsider our business risk calculations. A lot of my customers that I talk to look at vulnerabilities that we report and they might say, I've got a lot of

vulnerabilities to deal with. This one doesn't rise up to something I need to take action on right now until it does. We need to do much better at understanding what the risk is to businesses and what is going to be acceptable from a downtime perspective. Maybe we have critical systems that we have to think we can't operate in a post -mythos type of vulnerability discovery world when we have so many O days hitting us all the time where we're trying to schedule a two -hour outage window

to be able to reboot systems. to apply some patches. We have to really carefully reconsider that. And that's at the CISO level on down. Winston Churchill, one of my favorite quotes is, never let a good crisis go to waste. This is an opportunity. We can look at mythos. We can look at these problems. We can say, this is scary. Yes. I think the wise among us will also look at this and say, this is an opportunity. It's an opportunity for everybody on this webcast right now to be able to say,

how do I counsel my manager, my manager's manager, the CISO level? How do we get in front of this? How do we understand? How do we translate these kinds of practical risks into what's appropriate for your organization? Understanding your business is something that you will always do better than I will as a consultant every day. So how do you use your insight knowledge to be able to promote your position as an industry expert to help your organization understand what they need to do to stay in front of this? Don't let this as an

opportunity go to waste. Get in front. Establish yourself as a subject matter expert. Do the legwork. Do the research. Make sure you're speaking from confidence and with supporting information. But use your own insight to get in front of executives and other people in your organization to be able to give them the insight that only you can provide. I think we also need to do a better job at not losing grasp of the conventional controls. Although, yes, we're going to be seeing a lot more exploits, a lot more attacks, the traditional controls

also help us significantly. Limit the blast radius. When a system gets compromised, what else can the attacker do? Reduce your excess access. Privilege management and IAM systems need to be carefully scrutinized. Where can we really limit what an attacker can do and what privileges somebody has access to? Use your threat hunting techniques. Look for opportunities to shrink your mean time to detect, how long it takes to detect and react to vulnerabilities. And we need to really carefully think about how we can refactor and restructure

our incident response programs. We need to prepare our organization as well. Tabletop exercises have been a standard recommendation for incident response teams for many years now. And I think they will continue to be vulnerable, but we need to think about what those exercises look like in the modern mythos era. And that is not just, here's an attack and let's go through how we would respond to it. Here's 10 concurrent attacks, stretching your team beyond their capability. How do we deal with this? When one person that

typically leads the team and is the expert in all the things and knows who to talk to and where the bugs are and where the skeletons are, what happens when that person just doesn't have enough capacity to manage multiple incidents at the same time? These are the problems that we're going to have to deal with, and it's best if we can get in front of them as quickly as possible to know where we need the resources to be able to respond to these new threats effectively. The term that I keep hearing now is Von Ops. You've heard of DevOps. You've heard of all these

different things. But Von Ops is a vulnerability management program. You might also call this ASM. And these types of vulnerability management programs or attack surface management plans are what we need to start thinking about for our organizations. If attackers can find vulnerabilities in software that is high profile, it gets disclosed quickly, maybe patched quickly, we know how to deal with that. But how do we deal with it when it is broadly distributed across not just high

profile software, but every part of your organization? Vulnerability management for a long time has been based on a relatively small number of people writing exploits against high profile targets. That's how we manage zero days. And for most organizations, You will never see a zero -day exploit. That is changing. Because now you don't need the expertise that was formerly required to identify vulnerabilities and write exploits. AI is helping us with that, with mythos or even without mythos. And so now more and more organizations

are going to have to deal with these threats. This is a reality that we're going to have to deal with going forward. Chris, we can move on to the next slide here as well. One other piece of advice that I really want to offer people is this. Take a deep breath. It's really hard to keep on top of things. I was just saying an hour ago to my team, look, Opus released a new model. Opus 4 .7 is out. Yay. It's really hard

to keep on top of things. It's really difficult. And if you're feeling a little frazzled, if you're feeling like you're being pulled in a lot of different directions, we all are. I think the important thing is to stop and think about what is this going to look like? How is this going to affect our organizations? And what can we expect for the future? Now, I did a little speculation here on this graph. This graph is completely made up, so none of these numbers are real. And what I graphed is, let's say, how many vulnerabilities

are we seeing in, let's say, the national vulnerability database? On a year -over -year basis, it's about 40 ,000, about 40 ,000 new vulnerabilities a year. And I think in 2026, we're going to see probably... 20 times that with AI, maybe more, 40 times that with AI systems. But I think we're going to get to another point as well. Chris, if you could move ahead one more step. The thing that I think we haven't quite figured out yet

is what's going to happen when models are able to identify vulnerabilities in closed source software. Right now, Mythos and a lot of platforms are focusing on open source software. And this morning I opened Photoshop and I clicked on the About screen and I saw the list of open source elements that Photoshop links to for image parsers, for file parsers, for dealing with all kinds of different operations. And it's long. There is plenty of open source software vulnerabilities to attack closed source software. And I think

that's going to be the initial peak that we see going up here. But I think maybe in the next six months, 12 months, we're going to see AI models getting even better at reverse engineering closed source software. And that's going to create another peak. And that's going to be even more difficult for organizations to deal with. On the bright side, you might say, well, we've got some time to catch up because we're only really focusing on open source software vulnerability discovery right now with mythos and other models.

But I think that's going to change. And I think that's going to be another big jump in vulnerability discovery, whether it's this year or next year, it's definitely going to happen. Now, I think what's going to happen is we're going to see a time where that's going to plateau. Maybe it's a year, maybe it's five years, and we're going to see a very tumultuous time of vulnerabilities. But I think that's going to fall off. And eventually, software vulnerabilities will dry up. Maybe that's three years out. Maybe it's 10 years out. Nobody

knows right now. But I think over time, we will see a much more secure software ecosystem. I was talking to my cousin cybersecurity or my nephew, rather, cybersecurity professional, recent grad. And he was saying, yeah, all these vulnerabilities that are coming up because people are vibe coding software. Yes, but that's not going to continue. AI models are getting better. We'll see fewer and fewer vulnerabilities in vibe coded software. We'll see fewer and fewer vulnerabilities in

open source and then closed source software as well. So if you look far into the horizon, you keep looking, there's a glimmer. It's way over there, but there's a glimmer somewhere for a much more secure planet. And I want to be a part of that. And in order to do that, we have to take care of ourselves. We have to look carefully at what the opportunities are. We have to try to get in front of these things. And we've got a lot more really meaningful work to do. The future is pretty bleak in the next couple of

years, but I think that there's a bright opportunity in the years to come after that. Chris, we can move on one more. And we want to not just leave you with here's a bunch of problems, but we want to talk about here's some resources as well. So we put together a bunch of resources that I think are going to be helpful for people. So next week, there's an AI cybersecurity summit that SANS is hosting. This is free for live online access. If you're in the D .C., Virginia area

and you want to join, you can do so. But you can also join for free by streaming online. And even if you just sign up and kind of. Manage your work and kind of keep it on the side. I'm excited to see the really great content. That's on Monday and Tuesday next week, and you can join that as well. The Cybersecurity Alliance posted a paper that Ed told me about recently, and I really enjoyed it. It's called the AI Vulnerability Storm, Building a Mythos -Ready Security Program. It is much more CISO -focused than technical

-focused, but that is a really valuable resource for all of us. Because if you read this, there's a lot of actionable advice that I think is high level advice, but great for planning purposes. And I think that there's probably a lot of valuable content that you can share with your CISO to be able to give them insight into what's going on and what to do about these coming risks. Rob Lee, SANS Chief of Research and Chief AI Officer, is hosting what we're calling a Find Evil Hackathon.

This is a community building program to be able to build new software to fight attackers using AI tools primarily focused around forensic analysis. SANS is hosting some cash prizes. People can start building and you can get involved there. And I think that's a great community way to contribute back as well. And then, of course. Our SANS Security 543 class, the new two -day class that Ed was talking about earlier, AI -assisted source code analysis and exploitation for penetration testers, is something that we're... very proud of and

is only just getting started with that we also have a handout this is brand new it really we saw for the first time yesterday we made the content but we have a new um using ai for source code vulnerability analysis handout what we're calling our 543 field guide so you can grab that resource as well which summarizes a lot of the steps and a lot of the techniques that chris talked about in the presentation here into one nice uh densely information -packed page of guidance

on how to use AI tools for vulnerability analysis. So hopefully these resources are helpful to you, and I would definitely take a look at all of these resources to help you in your own journey about understanding how these tools are enabling attackers and what we can do about it as well. I think Ed will go back to you. yes uh that was great thank you josh thank you chris we've got tons of questions if i could ask the people who are running the webcast i know you want to focus back on our faces but can we leave that resource thing up because they're so valuable for folks maybe leave it up for three four minutes and

then come back so we can you know see the the beautiful chris lg shirt and and and josh your shirt's nice too um so but yeah leave that up for three minutes so people can get those resources but there are tons of questions Really good questions. I love how thoughtful this community is and how great these people are part of the SANS community. I'm going to start out, I'm going to bundle the questions because there's so many of them. So I'm going to bundle them and I'll shoot some to Chris, some to Josh, or if you want to answer the other person's questions, that's fine too. So Chris, I'm going to bundle these two for you.

First, is this just for... application or web app specific pen testing? And at what point would I switch from using the LLM in the, say, the 543 methodology to manual pen testing back and forth? So if you could answer those two questions together, I think that'd be great. Yeah, no, I was seeing the same questions in the comment thread there. So I'm glad you asked those, Ed. Yeah, so... Obviously, what we demonstrated is open source web application would work similarly for a compiled application as well. But no, like Josh pointed out, there comes a time and we're

already approaching it where the LLMs are good enough to reverse engineer things. I know some people have had luck already using LLMs in conjunction with applications like Ghidra to start doing some of that. So I think that's already on the horizon. We're also in our shop. doing some of this with hardware. And I know that still gets down to software at some point, right, where we're pulling out a compiled application and analyzing it. But Chris Davis and our team right now is working with an LLM and a Pico 2 and all the cool test harnesses and soldering and all that to do hardware work. So this absolutely

does apply to more places. And sorry, the second part of the question, Ed? At what point do you switch from doing this methodology that we saw to help find vulnerabilities to maybe traditional pen testing with lateral movement, et cetera, et cetera, back and forth? What does that flow look like? Yeah, so first I'm going to answer the question I want to answer. Because at first I understood that to mean when do you kind of stop with the LLM and start with the human? And really the human is going to be. mentally engaged the whole time. There are plenty of opportunities throughout the process for the LLM to kind of go in a weird direction and follow it on a path

that isn't going to be fruitful so that the human, the actual intelligence has to be engaged the whole time. But then, yeah, the next question with when does it switch to other tasks? Honestly, we're doing a lot of those with LLMs as well. We've found opportunities to have it do some of the traditional LLM &R poisoning and fabricating tickets. And again, with a human right there watching it, giving it permission to do different things. But there really doesn't have to be a hard handoff. We just have to make sure the human is engaged the whole time. You're right. Seamless.

Very well said. So, Josh, I have strong opinions about the next question, but I'm going to ask it of you because I know you'll probably give a great answer. Do you believe that AI pen testing, defined however you want to define it here, will become an industry standard for compliance purposes? From a compliance perspective, I think we're a ways out from that still. I think that there is some logic to that. I think that there is certainly some value in having a standardized

mechanism to be able to integrate that. But I think that from a governance perspective, we're pretty slow to adopt those things. It might take some time. I do think that there is probably an inevitable future where this is integrated into something that we're doing all the time. I think when we specify governance, I don't know that we would say you must use AI. I think it's much more outcomes driven. You must have a comprehensive

assessment to find vulnerabilities in your source code. But I think the logical play is that more and more organizations will start integrating AI tools into those processes. I think that's very well said, Josh. You know, if you'd asked me that same question, you know, a long time ago, like eight days ago, I would have said, no, it's quite a ways off. But then after what happened last week with all the bank, you know, CEOs being called in by Scott Besant and Jerome Powell. I think it might be coming sooner rather than later. It still weighs off. These are complex things. And then you know what's going on in

the EU as well as in the UK with all the awareness and concern of banks. My belief is that before too long, this will just become an expectation that, well, of course you did this. You had to do this. How else did you find the vulnerabilities? You didn't have a human go through it all, did you? And there's some economic arguments here, too. The expense of humans versus token costs are high. And in fact, that is another question. Maybe I'll talk to Chris Elgy about that one. So someone's saying, hey, you know, token costs are high. And sometimes models get really weird,

like Opus has been seemingly not as smart as it was three or four weeks ago. Recently, it's just kind of gotten stupid. So what about token costs? Do you think that... Once this isn't subsidized by all the investment capital, that this will actually become far less practical than it is now? Yeah, I'm thinking about Josh's graph, actually, right, where we see the curve go up. And if at some point, as some people predict, the VC bubble pops and we start paying the actual cost of the

electricity and the compute and everything, then it's I mean, it's necessarily. got to slow down, right? I mean, otherwise, we're just spending a lot more on it, either on the consultants or on internal token costs. So I've got to believe that's going to at least add friction to the process and not halt it. I think we'll all be a lot more mindful and have fewer throwaway single prompts, right? We'll be more responsible users, just like we bring reusable bags to the grocery store, right? But I think it will cause some friction and slow it down to some extent. I think you're right. I saw a tweet last week about somebody

who came up with a prompt for his AI, speak in caveman tones, because it just saves tokens. There's no articles like a and or the, it's just very grunt -like, but it saves tokens. Crazy world we live in. You two are like the perfect people to ask this next question of, okay? Because you help figure out the staffing for all of our projects, right? So for a high value project, what does staffing for this type of pen testing look like? Do you have any recommendations? How do you even construct a project that uses the techniques you just discussed? So I find that

on our team, there's a spectrum for people that love AI and are really great at it and also are very imaginative to people that are much more methodical. in how they go about finding vulnerabilities and maybe have been a little bit later to adopt AI, but are continuing to integrate that into their processes. And I think the interesting thing is they all contribute so meaningfully

to assessments and engagements, but they bring different things to the table. When we're looking at projects and we're planning on staffing and we're saying, OK, who's available and who's in the team and who is the expertise and things like that? We try to have a mix of different skill sets. You have to have the technical skill sets. You have to be great at penetration testing. Right. At CounterHack, we really don't have any junior analysts. Right. Everybody is well experienced in the industry, but people bring different expertise. And so we try to have. the super creative thinking

well outside the box, but we also try to have the person that is very methodical and can capture all the different elements there. And I think it's the combination of those different roles that really makes for the most effective engagements. Yeah, I think the other piece of that too is development, right? We're always trying to make our employees better. We always want to make people smarter. So, you know, Ed and Josh and everybody have done a lot to encourage us all. to learn, to get better at using this so that regardless of what our tendencies are, then we're

all better at using the LLMs for the tasks that they're good at. Yeah. And we want to share this with the community. That's why we wrote that two -day SANS class. In fact, we built an in -house CTF so that our team that does pen testing could learn these techniques through a fun kind of internal thing. And then at a certain point, we're like, well, why don't we turn this internal CTF, build all the lessons we want people to know about it, and then... offered as a class through SANS. So this is all very dynamically created here based on those needs. All right. I've got another one that I'll address to both

of you. You can order it out as you wish. I'm going to bundle like three different questions. There's sort of an optimistic view of a question, sort of the pessimistic view of the same question, and then something in the middle. Okay. So here's sort of... the optimistic view a lot of the vulnerable a lot of the recommendations that josh had suggested seem to be accelerated versions of things that companies have struggled to do for a long time are there more innovative solutions as well keep that in your mind so this is optimistic it's like there must be other solutions that we can apply right right here's the negative view of

it now they're releasing capabilities uh being exploited effectively everyone has to drop all their other investments and focus just on vulnerabilities josh is that telling us We got to drop everything else that we're doing that was cool and useful and just focus on this. So it's more of a negative view, which, hey, that's good. We need both, right? And then somebody said, I don't mind additional funds for these new workloads, but I'm worried about hospitals and schools, the people who are not flush with money, who are relying on razor thin budgets. Are there any recommendations for those? So, I mean, it's three different kinds

of views of the same thing, but what do we make of this? How do you prioritize your resources, your teams in light of what's coming? So, Chris, I'll go first. That's OK. I'll capture that. So I don't think anybody is saying drop every single project that you're working on. At least we should not be saying that because there's important work that is being done all over. I think that we need decision makers, which might not be us. We might be technical people doing

technical work, trying to get the job done. But we need decision makers to very carefully say. what are the priorities of the business? What do we need to do for the organization? I also think we need to be very careful about managing burnout. I think that it is very easy for people to become overwhelmed and then stop producing meaningful work. And that's not great for the organization either. And I think we need to very carefully look at staffing for all these things. I am concerned about the gap, the gap between people that are doing okay from a security perspective

and have the resources and have the money and have the investment and people that don't and i think that gap is getting wider and wider i think that it's going to create a more and more difficult scenario and that is schools that is small businesses that is medium businesses but it's also things like water refinement factories or water refinement plants and and you know um municipalities at you know in uh state or regional government level And I think this is going to create more and more of a problem for a lot of

organizations. I think that there is opportunity for AI to help with that as well. But I think right now we're seeing a lot more interest and emphasis on the attack side. And the defense side of things, while there are some vendors doing some great work there, isn't quite catching up or the costs are so prohibitive that... people aren't being able to catch up. This is why I think some of the projects like the Find Evil Hackathon that Rob Lee is hosting is such a great idea. Because I think when we embrace this as a community, we contribute our time and our expertise,

and we make open source software, that creates an option for a lot of people to shore up that gap. And then hopefully that drives down the cost of some of the more widely applicable commercial solutions too. Josh, I think you nailed it. Let me do one final question, then we'll close this out. Hey, Chris Elgy, are you providing suggested patches to your pen testing clients from stuff like this? Oh, yeah. So yes, we always have. We always will, right? So we could potentially offer full code, but at the very least, we're very specific about the kind of functions that

we want to see adjusted. or we're specific about the types of recommendations that we think will remediate the vulnerabilities. Absolutely. And sometimes that includes listing a code change that we'd like to see. However, we point out that we're penetration testers, not software developers, and these things need to be evaluated by skilled software developers and tested thoroughly in a QA environment. But that will bring us to a close. Our time is up. Chris Elgee, Josh Wright, thank you so much for sharing all of that information. Maybe we could real quick bring up the resource slide again for anybody who wants to take that

down. There's very useful things here. If you take just one of these away, read that Cloud Security Alliance paper written by Gadi Evron and Rich Mogul and Rob T. Lee of SANS. It's a great read. It'll give you a lot of insight and build on many of the things that we talked about here. But look at all these other resources too. I hope you find them useful. So on behalf... of Chris, Josh, me, and the entire Stan team. Thank you. And stay in touch. We appreciate it.

Open the transcript file

Hosts and Guests

Nobody is credited on this episode yet.

Credit the people on this episode

Be the first to rate this episode

More episodes

All episodes
  1. The Security Box, podcast 280 Intermediate F: Sony PlayStation 2011; GameOver Zeus: 2011-2013; and much more

    Nov 9, 20265 hr 55 minAudio

    Welcome to podcast 280 Intermediate D. I'm Jared and the podcast is now available for everyone. On this podcast, the Evolution of Cyber Security, part 3: Organized cybercrime and social engineering, part 5. The podcast...

    Credit the people on this episode

  2. TSB has an intermediate podcast dealing with PHP2Shell

    Oct 27, 20261 hr 12 minAudio

    Hello gang, welcome to the security box, program 280 Intermediate E. On this program, we're covering something called PHP2Shell two vulnerabilities that were disclosed the same day. Not only that, we have a third vuln...

    Credit the people on this episode

  3. Sans presents the newsletter for October 13, 2026

    Oct 26, 20263 hr 28 minAudio

    Welcome to Sans, episode 43 where your blood may decide to boil. I'm Jared, and this episode will cover the Newsletter that was released on October 13, 2026. On this newsletter, there will be some good news items that...

    Credit the people on this episode

  4. The Security Box covers news, notes, breaches of the week, Flame and SecurID (Secure ID)

    Oct 23, 20264 hr 59 minAudio

    Welcome to podcast 280 Intermediate D. I'm Jared and the podcast is now available for everyone. On this podcast, the Evolution of Cyber Security, part 3: Organized cybercrime and social engineering, part 5. The podcast...

    Credit the people on this episode

  5. Sans, episode 42 for the newsletter that was issued on October 9, 2026

    Oct 15, 20263 hr 23 minAudio

    Welcome to Sans, Episode 42. Its been awhile, and this episode explains why. I hope that we can continue Sans, I'm going to start on the next issue very soon now. If you want to read the newsletter, please use this link...

    Credit the people on this episode