# The Invisible Code Problem: When You Can’t See the Attack, Can You Stop It?

URL: https://securitytable.ai/the-invisible-code-problem-when-you-can-t-see-the-attack-can-you-stop-it/
Published: 2026-03-20
Duration: 2194 seconds
Season: 4
Episode: 4
Hosts: Chris Romeo, Izar Tarandach, Matt Coles

## Show notes and chapters

**In this episode, we dive into the strange world of invisible Unicode attacks and what they could mean for modern software security. We explore how hidden characters can be used to conceal malicious code within packages, why this isn’t entirely a new problem, and whether current tools, such as linters and SAST, are equipped to detect it. We also question the role of LLMs in both enabling and detecting these attacks, and whether this is a real emerging threat or just another overhyped security scare. Per usual, the conversation is filled with sarcasm, skepticism, and a healthy dose of “just don’t do it.**

  

Follow AI Security Table:

➜ Home: [https://securitytable.ai/](https://securitytable.ai/)

➜ X: [https://x.com/AISecurityTable](https://x.com/AISecurityTable)

➜ LinkedIn: [https://www.linkedin.com/company/ai-security-table/](https://www.linkedin.com/company/ai-security-table/)

➜ YouTube: [https://www.youtube.com/@AISecurityTable](https://www.youtube.com/@AISecurityTable)

## Transcript

**Chris Romeo (0:13)**: Hey folks, welcome to another episode of the Security Table where Matt can't stop laughing. It's been a while since you've heard from us. We were traveling the world. No, we weren't.

**Matt Coles (0:27)**: In our minds.

**Chris Romeo (0:28)**: I wish we could say that.

**Izar Tarandach (0:29)**: In our VR headsets.

**Chris Romeo (0:30)**: In our VR headsets. We were at the Eiffel Tower.

**Matt Coles (0:33)**: We were at the Fear of the Mind.

**Chris Romeo (0:37)**: Yeah, I don't want to wait. I don't even know what that means. The Fear of the Mind. Hold on. Now, Izar, if you're watching the video stream, appears to be striking a pose. He's about to say Vogue for all you kids of the '80s. So yeah, I'm Chris Romeo, joined as always by Matt Coles and Izar Terrindosh. and we unpack the wild, the crazy, the, uh, underside of security. What is on the underside of the security table? Is it just gum? Like used chewing gum or what would we find there?

**Izar Tarandach (1:16)**: That's an interesting question. I never considered that one.

**Chris Romeo (1:19)**: Don't you dare ask an AI agent either. Get outta here with your AI.

**Matt Coles (1:23)**: You're asking, who are you asking there, Chris?

**Chris Romeo (1:26)**: What's on the underside of the security table? Is it just, did someone just chew gum and like stick it under the security table?

**Matt Coles (1:32)**: To see the underbelly of the security table.

**Chris Romeo (1:35)**: Ooh, security table after dark.

**Matt Coles (1:39)**: That's like a completely different, different episode.

**Chris Romeo (1:41)**: Yeah, that's true. All right, well, let's get into this. We got a couple of, uh, let's deal with this. A couple things to deal with here. Let's deal with this supply chain attack one first, cause I think it's the easiest one. Because, uh, what is old is new again, I think is the answer. Because you guys remember the first Unicode attack, right? You're old enough for that.

**Matt Coles (2:04)**: Oh my God. Unicode is, was, was, maybe still is horrendous. Is it double? Is it single byte? Is it double byte?

**Izar Tarandach (2:13)**: No.

**Matt Coles (2:14)**: Is it triple byte?

**Izar Tarandach (2:15)**: It's 4 bytes.

**Chris Romeo (2:17)**: There's bytes for everybody. The legacy attack. If I remember, this is, we're going back a while, but I believe that the legacy Unicode attack was was equivalent to a dot dot slash. Well, at the end of the day, let you escape directories and things and execute code in places. I think there were, there were a couple of things, right?

**Matt Coles (2:36)**: There was, first off, there was the, the, the stack overflows, right? So you had Unicode characters. If you had, if you only planned for UTF-8 and then they suddenly got UTF-16, you got double byte characters and you can overflow buffers.

**Chris Romeo (2:49)**: Okay.

**Matt Coles (2:50)**: Right. And then you also had, um, like similar looking characters, characters from a different character set that allowed for, um, you know, phishing and spoofing and whatnot. Um, and then I guess you were talking about characters that behaved equivalently as./, um, wasn't familiar with that one, but, uh, that one sounds possible.

**Chris Romeo (3:14)**: That's the one that I saw in the incident response world. That's the one that, uh, our customers were getting hit with was the—

**Matt Coles (3:21)**: well, that was, you weren't thinking about Zip Slip, were you? Cause Zip Slip knows where you have embedded dot dot slashes in zip files later.

**Chris Romeo (3:27)**: Yeah, zip slip was later. I feel like the Unicode attacks were years before the zip slip attack, but it's not entirely possible.

**Matt Coles (3:35)**: Yeah, I mean, Unicode is like IPv6, right? It's, it's been around for ages, and people— some— now people use it all the time without— probably without thinking about it. Um, although if you're in the Python world, you have to think about it constantly because I don't know about you, but I get character encoding issues to on occasion.

**Chris Romeo (3:55)**: That sounds like a reason to use a different programming language.

**Izar Tarandach (4:00)**: No comment.

**Matt Coles (4:05)**: Show me one that handles it properly every time.

**Chris Romeo (4:08)**: Perl! Hold on, let me just have AI create one real quick.

**Izar Tarandach (4:13)**: Yeah, but the problem in this one, bringing us back to the present, is that apparently there is this new thing out there where UTF is being used to add invisible code inside packages out there.

**Matt Coles (4:35)**: And, uh, and of course humans can't see invisible code unless you have x-ray vision or, you know, see invisibility or something.

**Izar Tarandach (4:45)**: Which to tell you the truth, I think it was a wasted name of an attack. This could easily, they called it Glassworm.

**Matt Coles (4:52)**: It could have, wait, they named it?

**Izar Tarandach (4:53)**: Yeah. It could easily have been the attack of the invisible characters.

**Chris Romeo (4:59)**: Glassworm. Glassworm.

**Matt Coles (5:00)**: Who calls it Glassworm? That's lame.

**Chris Romeo (5:02)**: Right.

**Matt Coles (5:04)**: And the invisible code.

**Izar Tarandach (5:07)**: Yeah.

**Matt Coles (5:08)**: The shadow knows.

**Izar Tarandach (5:10)**: They, they say, okay, you, you get this invisible code inside popular packages that get downloaded, so it becomes a supply chain issue. And SAST, conventional SAST, won't see this because the characters are quote unquote invisible.

**Matt Coles (5:27)**: So, well, it, the SAST will still see the characters.

**Izar Tarandach (5:32)**: It just won't interpret them as anything nefarious. Which brings me to, to, to my first point here. They gave an excerpt of code found out there. And it's, uh, as expected, a loop that's mapping the, uh, UTF characters into something that's more readable and blah, blah, blah, and filter and whatnot. But then comes the last line, eval buffer from string. So, uh, looking at my, looking at my watch, it's 2026. I was still looking at code and seeing eval and not saying this is evil. I mean, talk about unintended consequences, right? Fine. You have this whole invisible thing happening and it's nefarious and it's horrible, but it ends up in an eval.

**Chris Romeo (6:26)**: Yeah.

**Matt Coles (6:26)**: Your, your linter should catch that. Never mind static analysis.

**Izar Tarandach (6:30)**: Your freaking eyes should get that. But the problem is that at, at the end of the, uh, What really irks me, the last character of the article, and these are not the original researchers, it's just somebody writing on the research. The best way to protect against the scourge, scourge, it means that it's all over the place, right? Thousands and thousands.

**Chris Romeo (6:55)**: That's an LLM word.

**Matt Coles (6:57)**: It could be anywhere. It could be anywhere. Who knows?

**Izar Tarandach (7:00)**: Right. On the other side of the security table, including. Um, of supply chain attacks is to carefully inspect packages and their dependencies before incorporating them into projects. This includes scrutinizing package names and searching for typos. Yeah, let me go to my developers and just tell them that now I expect them to check for typos inside the code.

**Matt Coles (7:23)**: Wait, wait, wait. If, if everything's invisible, what are they looking for?

**Izar Tarandach (7:30)**: Clearly for the evidence of absence of evidence of, uh, knowns, unknowns, plus typos. Like, look for something strange.

**Matt Coles (7:41)**: Well, why typos though? I mean, if you, if you can, if you can inject invisible characters into code, why can't you inject invisible characters into a title and make it properly named with no typos with invisible characters? With embedded characters.

**Izar Tarandach (7:59)**: Hey, therefore, that's why they continue the paragraph and gave you some clarity. If suspicions about LLM use are correct, malicious packages may increasingly appear to be legitimate, particularly when invisible Unicode characters are encoding malicious payloads.

**Matt Coles (8:18)**: So, again, what is the, what is the, what is the, what is the mitigation here? It's for humans to look at something that they can't see.

**Chris Romeo (8:26)**: Yeah, that sounds like a plan.

**Izar Tarandach (8:30)**: No, no, no, no, no. Wait, not only they can see, but also has typos.

**Matt Coles (8:34)**: How about, how about a simple, how about a simple grep looking for a certain set of Unicode characters? I mean, add it to your linter and be done with it. Right. If you find it, you don't need to review any further. It's suspect. Throw it away. Right. They did say that there are legitimate cases for this. I don't know of any. If you, if anyone has any good examples of when you would want to use UTF Unicode characters that are invisible to the, to humans, maybe for control codes, you know, maybe it's control characters we're talking about here, but if I want to store a secret in my code, uh, would you store it as invisible characters?

**Chris Romeo (9:12)**: Yeah. I was just joking.

**Matt Coles (9:13)**: For those who don't know, for those who aren't familiar with that term, security by obscurity, or in this case, security by invisibility.

**Chris Romeo (9:26)**: I mean, that's cool.

**Matt Coles (9:27)**: This is just, I don't know, this, and this is not an LLM problem, right? This could have, this could have happened for decades.

**Izar Tarandach (9:34)**: Oh, there's more.

**Chris Romeo (9:36)**: Oh, there's wait, but wait, there's more.

**Izar Tarandach (9:39)**: Yeah. Let's make it an LLM problem because here in the middle, uh, the researchers suspect that Glassworm. The name they assigned to the attack group, is using LLMs to— no, that's not the one. Sorry. Sorry. Um, oh, the invisible Unicode characters were devised decades ago and then largely forgotten, as they should have been, or actually as they shouldn't have been devised. That is until 2024, when hackers began using the characters to consume malicious prompts fed to AI engines. While the text was invisible to humans and text scanners, LLMs had little trouble reading them and following the malicious instructions they conveyed.

**Matt Coles (10:24)**: So wait, it's not white text on white background anymore?

**Izar Tarandach (10:26)**: Yeah, but you know, I, I, I'm a bit confused here because even then, if you're using this, this invisible characters, it's not an A, B, C that's invisible. It's a bunch of characters that are not represented. Like visually, but there's a tail between us.

**Chris Romeo (10:50)**: A tail of two cities. It was the best of times, it was the worst of times.

**Izar Tarandach (10:55)**: That's Nessie, the cat from Loch Ness. At least it's not Sir. Okay, if you're not watching this, Matt has just been invaded by a tail of a cat. Okay, cat's gone.

**Matt Coles (11:09)**: He'll be back, I'm sure.

**Izar Tarandach (11:12)**: He'll be back. So how does the LLM actually interpret these Unicode characters as a bad prompt if their only meaning is being in a range that's not visually represented? I'm confused here.

**Matt Coles (11:27)**: Well, also, I mean, we know how LLMs tokenize. We know how, we know that LLMs tokenize strings. And so does the tokenization actually catch the individual characters enough to convey meaning. I guess, you know, an interesting experiment, you could ask an LLM to produce sentences with invisible Unicode characters. It knows the entire character set, right? And it should be able to identify those things. Like, show me, you know, tell me the book tell me which books have this string in it.

**Izar Tarandach (12:13)**: Now you're using an LLM as a grep engine to look for.

**Matt Coles (12:20)**: Show me all the code package. I'm looking for a piece of code because I want to use it. Show me all the code packages that have this construct.

**Izar Tarandach (12:29)**: I don't think that that would work.

**Matt Coles (12:32)**: I don't think it will work well. Cause it may just invent them.

**Izar Tarandach (12:38)**: It probably would, but anyway, it would try and use a tool to go and search the web. It wouldn't look inside its own model and see what representations do I have in here.

**Matt Coles (12:48)**: What if you told it not to?

**Izar Tarandach (12:50)**: Hmm?

**Matt Coles (12:51)**: What if you told it not to?

**Izar Tarandach (12:54)**: Still, it would probably just invent something because I don't think that that's how the query bits works. You can't, I don't know.

**Matt Coles (13:05)**: It can predict, remember it's a prediction engine, right? So it won't do it reliably.

**Izar Tarandach (13:12)**: That goes without saying it won't do anything reliably.

**Matt Coles (13:16)**: Or repeatably, maybe reliably is, uh, it's probably the wrong word. Repeatably is the—

**Izar Tarandach (13:21)**: you can't rely on the, on the consistency of the result, right? It will do things reliably, but what you get out of it is not reliable.

**Matt Coles (13:30)**: Someday we should have a talk. We should have a chat about rule-based versus LLM-based processing, given the non-determinism and how that affects security.

**Izar Tarandach (13:40)**: Well, we could just bring that down to LLM-based threat modeling and rule-based threat modeling. And, you know, one of them is always going to give you the same result given the same input. The other one, your threats may vary, but it would be interesting to me to know how much constraint, how many constraints and how effective they would be if you would try and make the LLM-based one act as if it would always give you the same thing.

**Matt Coles (14:17)**: Isn't that what RAG is for? Confirm, validate your results against this dataset. And only use this dataset.

**Izar Tarandach (14:23)**: No, that, that's, that's for, that's for, uh, grounding the, the, the, the, the, like the space that you're going to answer about. It's saying don't go around and invent stuff or go look for stuff.

**Matt Coles (14:37)**: But, uh, my problem is that you constrain this dataset, right?

**Izar Tarandach (14:42)**: But that doesn't guarantee that the result and resulting threads that you're going to get are going to always be A, B, C. You could get C, B, A. You could get A, G, and B.

**Matt Coles (14:52)**: Right.

**Izar Tarandach (14:52)**: That, that's, that's where I would be into. I'm sure that some university out there, probably the guys in Belgium have already looked at this kind of stuff. And actually I'm going to look for it as soon as we finish here. But, uh, again, those guys do the great work. Huge, huge respect.

**Matt Coles (15:12)**: Who needs invisible characters when you can just, uh, pose a different question to Isar and Sidetracked.

**Izar Tarandach (15:18)**: It's shiny. It's shiny.

**Chris Romeo (15:20)**: So what do we, at the end of the day, what do we do with this? Is it just a new class of attack that we got to worry about?

**Matt Coles (15:27)**: Does it? It's a simple fix. Again, just add it to your linter looking for those Unicode characters. If you find—

**Chris Romeo (15:32)**: but what are you looking for? What are you scanning for? The, cause these are packages. So scanning the packages, you're scanning the packages for a range of characters.

**Izar Tarandach (15:41)**: Uh, I'm, I'm sorry, but I'm going to go back to the roots here. Like at some point you have a string that maps to whatever is bad and that string has to be executed.

**Matt Coles (15:52)**: Well, yeah, but if it doesn't, if it goes to eval, that's obvious, but what happens if it goes to a Popen or a system that you expect to see, right, in the code normally?

**Izar Tarandach (16:04)**: Would you expect to see something that jumps into user-provided or hardcoded stuff and just starts executing it.

**Matt Coles (16:14)**: It doesn't have to necessarily be that if you take an input stream and then you tack on characters to it, right? Maybe you get a command injection. Maybe you introduce a command injection that wasn't there previously, but again, or a SQL injection, but something is going to be executing potentially tainted code.

**Izar Tarandach (16:33)**: You can flag for that.

**Chris Romeo (16:35)**: This isn't, this ultimately a repo problem. Like, shouldn't the repo just block the upload of a new version of a package that has invisible code in it and call it done?

**Izar Tarandach (16:46)**: That's one way, of course, but not everybody takes code from repos.

**Matt Coles (16:51)**: But also, well, I think what, I think what is, uh, what is, or what, uh, Chris is saying is if somebody is going to maliciously inject code into a repo, you can stop it at that point and don't allow it to be introduced right in the PR. For instance, I mean, that doesn't stop a legitimate developer, like a maintainer, from introducing code because they might bypass the PR process.

**Chris Romeo (17:16)**: Yeah. But if you had some type of check, like, I believe that when I upload a new version of a package to a repo, isn't there some scanning that's happening to that package?

**Izar Tarandach (17:29)**: Some of them. And. Of course, as we well know, different kinds and levels of scanning. But I think that these guys are saying that SAST usually doesn't see it. Yeah. Static analysis tools see only whitespace or blank lines.

**Chris Romeo (17:46)**: So the scanner might not even—

**Matt Coles (17:48)**: wait, whoa, whoa, whoa, whoa. Hold on. The, the SAST tools are not looking at what gets rendered. The SAST tools are looking at what's, what bits exist.

**Izar Tarandach (17:57)**: Exactly.

**Matt Coles (17:58)**: And so as long as you're not encode— not, they're not being doubly encoded in a way that the scanner can't unpack them. Right. So scanners won't go into Base64 encoded because usually that's, those are strings that it doesn't need to look at. If that's a code block, if that's an executable code block, then that's a problem, right? The scanner should be fixed for that. Um, again, a linter. right? And a linter, you could then look for variations or variants, right? And forget— so linters are just basically grep, right? They're basically looking for string patterns, regexes. They're not— I'm not saying any of these are universally perfect, but they get you to a place where at least maybe you flag suspicious things, right?

**Chris Romeo (18:48)**: So we're basically doomed. We're doomed.

**Matt Coles (18:50)**: Or do you know?

**Izar Tarandach (18:51)**: Because, because the next, the next line, it says to a Java, JavaScript interpreter, the code points translate into executable code. What's, what's ringing in my head is that you can't have it both ways. You can't have SAST ignoring it as whitespace and JavaScript looking at it and seeing executable code.

**Matt Coles (19:09)**: Yeah.

**Izar Tarandach (19:10)**: Because you're missing a mapping in here and that mapping is going to get a string transformed into something that can actually be. Interpreted. That's the point of an interpreter, right? So that's an interesting—

**Matt Coles (19:22)**: actually, and that's an interesting question. So they're using, they're using JavaScript, which is an interpreted language, right? How does, how does this multi-byte Unicode get compiled if you mix character sets in as executable, as compilable and linkable executable code? Does the compiler actually handle that properly?

**Izar Tarandach (19:43)**: Look, it's beyond that. No, it's beyond that. It's beyond that.

**Matt Coles (19:47)**: Because, you know, I mean, if you try this in C or you do, I mean, it may, it may not work, period.

**Izar Tarandach (19:53)**: No, it doesn't matter. It doesn't matter because whatever you create that is not part of the language syntax is going to get flagged by whatever is compiling or interpreting it because it's not part of the language syntax. So in order to use those things, you have to put them into some block. That is not compiled or interpreted. So it's either a comment or a string. If it is a comment, compilers will drop comments unless you explicitly tell them, and I don't even remember if that's possible nowadays.

**Matt Coles (20:25)**: If you, uh, if you don't strip, well, you can, yeah, uh, compiled languages, I think, will always strip comments.

**Izar Tarandach (20:30)**: Yeah.

**Matt Coles (20:31)**: Right. It's symbols and things that you, that you may have.

**Izar Tarandach (20:33)**: And strings, I'm sorry, the language is just doing what the language is supposed to do and it doesn't care about what's inside the strings. It's just bytes for it.

**Matt Coles (20:41)**: It just puts it in a data block, right?

**Izar Tarandach (20:43)**: It doesn't matter if it's multi-byte or whatever, that's in the construct of the, in the format of the bytes, not in the fact that there are bytes in there.

**Matt Coles (20:51)**: Right. And so then you have a, then you have a reader for those bytes that would be, have to be multi-byte aware.

**Izar Tarandach (20:57)**: Exactly. But then it brings back to my initial point. You had a mass of bytes in there. It didn't get compiled. It didn't get interpreted. It got remapped. Into something that can be executed. And then you have some jump, some entry point, something that makes that thing be executed. And that's where you can flag the whole thing. So unless you have a package that, as you said, expects to see evals of strings, in which case you shouldn't be using that package because frankly, that's stupid.

**Matt Coles (21:35)**: So never, never mind any control codes whatsoever.

**Izar Tarandach (21:39)**: No, I mean, you know, I'm, I'm just, it looks like a very interesting academic exercise. It's almost like, I don't know, can we call this steganography for executables? But beyond that, I wonder, tools should be there to, to catch it.

**Matt Coles (21:59)**: I wonder though, if there is a legitimate use for this, thinking about, if you think about things like memory-constrained code, right? You're looking at embedded code or firmware. Is it memory efficient for these Unicode characters to exist? They're probably multi-byte characters. So you're already losing space there, but if you can encode particular pieces of data, of information that way, it might be actually valuable.

**Izar Tarandach (22:29)**: I would have to have a good use case for it because again, it seems to me like you're putting simple bytes into multi-bytes, you're already losing space.

**Chris Romeo (22:40)**: Yeah.

**Izar Tarandach (22:41)**: And it's probably not going to compress nicely. So why go up when we want to go down? I mean, There must be some use for this thing. Somebody woke up one bright morning and said, hey, I'm think— I, I think I'm gonna create this, this private use areas or private use access areas in Unicode so that people can do stuff. I don't know what the stuff was that they were thinking about, but there must be some because Unicode is a standard and hopefully people looked at this and said, yeah, we agree. That's a good idea. But right now, I don't know, I'm looking at this thing and I'm saying we should have the tools to deal with this stuff. It's not, it's novel, probably, but is it something to lose sleep at 3 in the morning? Don't think so.

**Matt Coles (23:39)**: You would want to check, you want to check with your, with your code linters and your SaaS tools to see if they're finding. Finding these and then update them if they're not.

**Izar Tarandach (23:47)**: Yeah, definitely.

**Chris Romeo (23:48)**: You're gonna, you're gonna love the reason why these things exist.

**Izar Tarandach (23:52)**: Why?

**Chris Romeo (23:55)**: Uh, corporate icon fonts. Companies frequently store custom icons in PUA code points, private use areas.

**Matt Coles (24:05)**: Apple says this is not in a, these aren't in a private use area code block.

**Chris Romeo (24:10)**: I thought that said it was.

**Matt Coles (24:12)**: Yeah, it says code.

**Izar Tarandach (24:12)**: Yeah, no, they are.

**Matt Coles (24:13)**: Well, no, it says the code prints in question are actually not in any of the Unicode private use areas despite what the article suggests.

**Izar Tarandach (24:24)**: Okay, this is a very confusing article.

**Matt Coles (24:26)**: So this is the, this is the Ars Technica article talking about this. So they interpreted it as non-private use.

**Chris Romeo (24:37)**: Wait, maybe the, maybe the article, uh, has conflicting viewpoints. 'Cause I'm reading the invisible code is rendered with private use areas, sometimes called private use access, which are ranges in Unicode for special characters. So I think it, I don't know, sounds like it might be, but the point is like the hidden, they, they created this private use area for nothing of really any value for having a—

**Matt Coles (25:05)**: oh, sorry, that was like the article itself that It was in a comment from the article. My bad.

**Chris Romeo (25:10)**: So co— so corporate icon fonts, Apple logo and vendor symbols, historic or unencoded scripts, corporate internal documents. Wait, this is getting weird. Specialized typography, emoji before standardization. They used to keep emojis in the PUA.

**Izar Tarandach (25:27)**: Mm-hmm.

**Chris Romeo (25:28)**: Music, mathematics, and notation systems. So like it basically exists for no real reason. Of any legitimate—

**Matt Coles (25:36)**: No, it exists for a legitimate reason. The legitimate reason is we didn't think of everything, and so we need a place to put other things that we didn't think of yet.

**Izar Tarandach (25:44)**: Well, apparently now it was given a legitimate reason.

**Matt Coles (25:47)**: Yes, it's hacking code now.

**Izar Tarandach (25:51)**: Yeah, it's too high school.

**Chris Romeo (25:52)**: This is why we can't have nice things.

**Matt Coles (25:55)**: Exactly.

**Chris Romeo (25:56)**: Yes, it's where it always comes back to.

**Matt Coles (25:58)**: It always comes back to variations or inconsistencies in a spec. Anytime you see undefined behavior or put your stuff here, bad things happen.

**Izar Tarandach (26:10)**: I think that the expression you're looking for is unintended consequences.

**Matt Coles (26:12)**: Yes, yes. Things like divide by zero, or there's a host of those in C, like undefined behavior between compilers.

**Chris Romeo (26:23)**: Okay, kids listening at home, when you think you have a bright idea about something that's going to revolutionize the future, don't do it.

**Izar Tarandach (26:30)**: You don't.

**Chris Romeo (26:31)**: Okay. Because probably the answer is bad idea.

**Izar Tarandach (26:36)**: Call us. And very much like somebody that we really, really like and respect, all you're going to hear is, uh-huh, but, uh-huh, but, and believe me, nothing like a but to drop your idea in place. Oh yeah.

**Matt Coles (26:53)**: That's worked. That's worked really well in the past.

**Izar Tarandach (26:56)**: Right? Yes.

**Matt Coles (26:57)**: Yes. But.

**Izar Tarandach (27:00)**: I love it that we have some proponents of yes and, and some very strong proponents of yes, but, and we pendulum between both of them.

**Chris Romeo (27:10)**: You forgot about the most important response. That's the stupidest thing I've ever heard in my life. No, no, no, no.

**Izar Tarandach (27:16)**: That's what everybody's thinking. I'm talking about what everybody's saying. Just say it.

**Chris Romeo (27:21)**: Just say it. Be transparent.

**Matt Coles (27:22)**: I think there's an opportunity for you to learn and grow with this.

**Chris Romeo (27:26)**: Dude, have you ever tried that on anybody?

**Matt Coles (27:28)**: Yes.

**Chris Romeo (27:29)**: It worked.

**Izar Tarandach (27:31)**: Wait, wait, wait, what did you try?

**Matt Coles (27:33)**: This is an opportunity for you to learn and grow.

**Chris Romeo (27:36)**: I feel like somebody would give you the finger if you said that.

**Izar Tarandach (27:39)**: I feel like he tried that on me.

**Chris Romeo (27:41)**: That was actually a mind trick on Izar.

**Izar Tarandach (27:45)**: And it worked.

**Matt Coles (27:47)**: You were an early victim, yes.

**Chris Romeo (27:48)**: Yeah.

**Izar Tarandach (27:49)**: Oh gosh.

**Chris Romeo (27:52)**: Wait, did you used to work for Matt?

**Matt Coles (27:55)**: I was. Yes, he did.

**Chris Romeo (27:56)**: You worked for Matt?

**Izar Tarandach (27:59)**: Yeah.

**Chris Romeo (27:59)**: Ah, okay. All right. We'll have to have a special episode without Izar so we could talk about his work performance.

**Izar Tarandach (28:08)**: Wait, let's, let's just put it like this. The word surprising, the word surprising was used in the review.

**Chris Romeo (28:16)**: Wow. I've never seen that happen.

**Matt Coles (28:18)**: Challenging employee.

**Chris Romeo (28:19)**: I can believe that.

**Izar Tarandach (28:21)**: No, I'm not.

**Chris Romeo (28:24)**: Argue about that. All right, well, I think we landed somewhere.

**Matt Coles (28:31)**: Yeah, it's just don't do it. It's the inverse of that other, of that shoe brand. Don't do it. We need a t-shirt. We need a t-shirt with a good logo.

**Izar Tarandach (28:42)**: Just don't do it.

**Matt Coles (28:43)**: Just don't do it.

**Izar Tarandach (28:44)**: Oh wait, let me write that down.

**Matt Coles (28:48)**: That's clever.

**Izar Tarandach (28:48)**: That's actually It goes together with my, uh, just because you can't doesn't mean your AI should.

**Chris Romeo (28:55)**: Yeah.

**Matt Coles (28:56)**: Yeah.

**Chris Romeo (28:56)**: That's true.

**Matt Coles (28:57)**: Well, apparently that, that, that goes for Unicode, invisible Unicode characters.

**Chris Romeo (29:03)**: Yeah. With somebody will get that on a shirt.

**Matt Coles (29:05)**: That's too, if you put it, if you put a string, if you put a constant, you know, string with quotes with, with missing characters.

**Chris Romeo (29:12)**: No, no, just put, no, here you go. Put the, put the invisible Unicode characters in the string. They'll never see him coming.

**Matt Coles (29:18)**: They'll never see it coming.

**Chris Romeo (29:20)**: Yeah.

**Izar Tarandach (29:20)**: I'm sorry, but what I'm thinking about—

**Matt Coles (29:22)**: What you don't know about can hurt you.

**Izar Tarandach (29:24)**: I'm sorry, but I'm thinking about the logo of a very, very well-known agent maker.

**Matt Coles (29:31)**: You don't need to take notes, César. It's now recorded for posterity here in this podcast.

**Izar Tarandach (29:35)**: Yeah, but if—

**Chris Romeo (29:36)**: Oh wait, we were supposed to hit record.

**Izar Tarandach (29:39)**: I'm old.

**Matt Coles (29:40)**: It's been a while.

**Izar Tarandach (29:41)**: I know, but I'm still thinking about my social media manager is DevNo. Is that a good one or not?

**Chris Romeo (29:52)**: It doesn't really make sense.

**Izar Tarandach (29:54)**: I think so.

**Chris Romeo (29:55)**: Because you wouldn't have any posts.

**Izar Tarandach (29:58)**: Yeah. Wouldn't that explain a lot?

**Matt Coles (30:03)**: What social media are you using that you can actually tell other people?

**Izar Tarandach (30:07)**: DevRandom. My social media manager is DevRandom.

**Chris Romeo (30:11)**: DevRandom is crap. There's no— it's terrible. Okay, you're random. That's pretty crappy too though, isn't it?

**Matt Coles (30:18)**: I seed my RNG with invisible characters.

**Chris Romeo (30:22)**: Oh, maybe that's why they exist. Oh, seeding an RNG.

**Matt Coles (30:27)**: And that's an interesting, that's an interesting attack. That's an interesting attack. You have rand prends with nothing inside. As a code review, how would you, you wouldn't know it would be a fixed string.

**Chris Romeo (30:36)**: You'd have, yeah, but it would cause you to freak out.

**Izar Tarandach (30:38)**: I'm sorry. You just missed a really, really good t-shirt here. I see invisible characters.

**Chris Romeo (30:45)**: With a picture of Haley Joel Osment on it.

**Matt Coles (30:50)**: Wait, wait. Okay. You can, you can, you can modify that to just go with, I see dead code.

**Izar Tarandach (30:55)**: Wait, don't we have that one?

**Matt Coles (30:58)**: Do we?

**Izar Tarandach (31:00)**: 0xdeadcode? I think I saw that one once, probably on Slashdot.

**Matt Coles (31:06)**: Maybe.

**Izar Tarandach (31:07)**: Ooh, remember Slashdot when it was good?

**Chris Romeo (31:09)**: Yeah, I just, I hadn't thought of that in a long time.

**Izar Tarandach (31:12)**: Remember?

**Matt Coles (31:13)**: Remember? Remember?

**Izar Tarandach (31:16)**: I remember.

**Matt Coles (31:17)**: Until it was replaced with a little shell script.

**Izar Tarandach (31:20)**: Yeah. Okay. So the next one in line is—

**Chris Romeo (31:27)**: I don't know. Maybe we should, we should probably save that for another day.

**Matt Coles (31:30)**: Yeah.

**Chris Romeo (31:30)**: You think so?

**Matt Coles (31:31)**: Yeah.

**Chris Romeo (31:31)**: I think so too. We're already, uh, we, we're, we've already captivated and entertained our audience for a lot of time.

**Izar Tarandach (31:39)**: We haven't dropped anybody from any running treadmills in a long time. Well, we need to do—

**Chris Romeo (31:46)**: probably not till this episode. I mean, this is riveting television. Invisible Code and you.

**Matt Coles (31:51)**: But I have to say, you know, when we do make it to that other article, we have to talk about forcing backgrounds to be the wrong color. When you want a dark mode, you don't need to get blasted in your face with Bah, that's my browser doing that. Not like the lights in my room.

**Izar Tarandach (32:11)**: Wait, you don't have the dark mode extension?

**Matt Coles (32:15)**: I have dark theme running.

**Izar Tarandach (32:17)**: And no, there's an extension for Chrome-based browsers that forces too white stuff, too bright stuff into dark mode. That's actually good because I can see it in our glasses.

**Matt Coles (32:33)**: Right, right. And so, you want to turn on the lights?

**Chris Romeo (32:38)**: This completes our new segment called Extension Corner, where provides a recommendation on a Chrome-based extension that you think that you really need to look at. Extension Buddy, I like that right there.

**Izar Tarandach (32:55)**: That's the only one No, it's the name of an extension that you should look into. We'll save that for next week.

**Chris Romeo (33:01)**: There's a bonus. Now he doubled up extension corner. We don't have anything else to talk about next week.

**Izar Tarandach (33:05)**: The first two ones are free.

**Matt Coles (33:08)**: We had, we had a third, but we couldn't see it.

**Chris Romeo (33:10)**: That's the drug dealer method of extension buddy or extension corner is where you, the hidden extension, you get away with free and see who comes back for more.

**Matt Coles (33:18)**: This is the invisible extension.

**Izar Tarandach (33:19)**: Yeah.

**Chris Romeo (33:21)**: All right folks, welcome or fuck. I've been away from this for a long time. Welcome to, and now we're actually gonna start.

**Izar Tarandach (33:31)**: No, no, no.

**Chris Romeo (33:31)**: Welcome to the end.

**Matt Coles (33:32)**: Oh, now you're gonna hit record.

**Chris Romeo (33:34)**: Great. Yeah, we're, uh, I promise next episode we will be just as irreverent and unprofessional as we were in this.

**Izar Tarandach (33:42)**: But wait, wait, wait. There's more. There's more. We approaching the 100. We, we need ideas from our, uh, uh, from our folks, our audience, from our subscribers.

**Chris Romeo (33:52)**: Australia, maybe they can get together for a watch party.

**Izar Tarandach (33:54)**: Yeah, from the folks in Australia. What, what they want to see on the 100.

**Chris Romeo (33:57)**: Watch party, Australia is not that big of a continent.

**Izar Tarandach (33:59)**: Oh, and that reminds me, there's only one Security Table. The other one is not a Security Table. This one is the Security Table.

**Chris Romeo (34:06)**: This is the original. I should have started with that. Let's start over. Welcome to the original Security Table. We are the original. We've been, I had this idea 5, 6 years ago for the, for the Security Table because somebody else started a podcast called The Table. And I was like, oh, that's kind of a cool idea. Just a few people sitting around having a conversation in this, this kind of—

**Izar Tarandach (34:27)**: so you see that, that, that's how things happen. Somebody has an idea. It's a good idea. You build on that idea. You don't go, oh, those guys have a security table. That's a great idea. I'm going to start a security table. That's not how it works.

**Chris Romeo (34:39)**: So we're officially feuding with the other morning show. Let's send a bunch of pizzas to their house. Arrgh, me mateys. Do all kinds of wacky morning show things.

**Izar Tarandach (34:55)**: Let's send them some invisible characters. There you go. Put them in an email.

**Chris Romeo (35:00)**: They'll never see them. Never see 'em coming.

**Matt Coles (35:02)**: White, white on white text.

**Chris Romeo (35:04)**: We'll show them.

**Izar Tarandach (35:05)**: And right now they just got more promotion than they ever have.

**Chris Romeo (35:09)**: So that's true.

**Izar Tarandach (35:10)**: You guys can thank us later.

**Chris Romeo (35:11)**: Yeah. Bills in the mail. All right. Have a great rest of your day, your week, your month, wherever you find yourself on planet Earth. Keep things secure and keep rocking in the— wait, wait.

**Matt Coles (35:22)**: What happens if you're on the moon or in space? You, wait, the people in the International Space Station are not allowed to have a good day.

**Chris Romeo (35:31)**: Well, I hope they're not allowed to have Unicode, invisible Unicode characters. No, but, but, 'cause they're in a controlled system.

**Matt Coles (35:36)**: If anyone needs them, it's probably them.

**Izar Tarandach (35:38)**: But you know that in there it's like, good morning, good morning, good morning, good morning, good morning. Because as it moves, it just keeps going. It's a new day.

**Chris Romeo (35:46)**: It's a new day.

**Matt Coles (35:48)**: If anyone on the International Space Station is listening to the, or watching this podcast, please leave a comment.

**Chris Romeo (35:54)**: Send us a message, please. That would be so cool.

**Matt Coles (35:57)**: Is anybody out there?

**Izar Tarandach (35:58)**: No, don't. You probably have more important stuff be doing.

**Chris Romeo (36:01)**: That's true. Pay attention to the rotating, I don't know, something that controls the thrust or something.

**Izar Tarandach (36:12)**: All right.

**Matt Coles (36:12)**: With that, I can see the security table from my house.

**Chris Romeo (36:17)**: With that, we say adieu. Adieu. Of course we do.

**Matt Coles (36:23)**: Adieu.
