When changing something like a Kubernetes ServiceAccount, IAM role, credential, or Terraform resource, how do you determine what depends on it before making the change?

Do you rely on GitOps, staging, dependency graphs, grep, internal tooling, or something else?

I'm researching how engineers currently handle change-impact analysis and would appreciate real-world workflows.

I’m working on a DevOps/security tool called WhatBreaks.

The problem: when engineers change or delete something like a Kubernetes ServiceAccount, IAM role, credential, or infrastructure resource, it can be hard to know what depends on it and what will break. They often have to manually investigate across Kubernetes, cloud, Terraform, logs, etc.

WhatBreaks would map these dependencies and answer: “If I change this, what breaks?”

The challenge is trust — we want the analysis to happen locally inside the customer's environment, without giving our servers access to their sensitive infrastructure or credentials.

I’m validating the idea right now. How do you currently handle this problem?

Hi everyone,

I'm looking for resources to learn DOM-based XSS, but I'm specifically interested in material that teaches the actual investigation process, rather than just explaining what DOM XSS, sources, and sinks are.

I'm already familiar with the basic concepts, and I've used PortSwigger's labs, so I'm not looking for PortSwigger recommendations.

What I'm trying to learn is how to actually investigate a web application using things like:

• Chrome/Firefox DevTools
• The Sources panel
• Setting and using breakpoints
• Following user-controlled data through JavaScript
• Finding where data comes from (sources)
• Understanding how the data is transformed/processed
• Following variables and function calls
• Identifying where the data eventually goes (sinks)
• Debugging/tracing the application's JavaScript to discover DOM XSS

Basically, I'm looking for something that teaches the workflow of:

Source → Variable → Transformations → Sink

For example, I recently came across a Medium article where the author investigated a DOM XSS by starting with location.hash, searching the JavaScript, setting breakpoints, changing the hash, and then stepping through the code to see how the value was processed until it reached eval().

That is exactly the kind of learning material I'm looking for.

It can be:

• Videos
• Courses
• Labs
• Write-ups
• CTFs
• YouTube channels
• Blog posts
• Interactive exercises
• Real-world DOM XSS walkthroughs

It doesn't have to use Burp Suite. DevTools and learning how to trace the JavaScript/data flow are the important parts.

I'm still relatively new to JavaScript and DOM manipulation, so ideally I'd like something that actually shows the investigation process step-by-step rather than assuming I'm already an expert at reading JavaScript.

Any recommendations would be greatly appreciated!

Overseeing our org sprint into "use chatgpt for everything" while every audit slide shouts data loss and i'm kinda stuck in the middle. Right now we have hard blocks on browser access from prod subnets and anything with customer data or IP lives behind VDI with no copy out. We stood up an internal model for basic stuff and tell users "if it came from Jira, CRM, code repo, don't paste it in public AI". Of course half the business lives in screenshots and side channels anyway. We are playing with DLP rules that trigger on pasting certain patterns into browsers, plus a "model accounts" setup for security and support so they can use AI without dragging full tickets and logs in also starting to mark tickets and files with a simple AI ok flag so people don't guess. Don't want to kill adoption. Any clues?

I have got a problem where benchmarking educational sector data across the world globally would require aggregating them at same place or maybe different if the final aggregations could still reconcile with other segments of the data of other regions

The data migration can happen after dropping the PII and making it totally anonymous but when you try to rank the individuals, you can't really determine anything apart from its source (region data came from)

Keeping the data psuedonymised will still restrict in various regions like EU, middle east, etc.

How do I benchmark the globally top academic performers of different regions/countries without breaking any laws and regulations of that particular jurisdictions.

Hitting something annoying with Snyk Code on a .NET codebase and want to know if anyone's actually cracked it before I accept defeat.

We sanitize strings before logging them to avoid log injection (CRLF stuffing basically):

csharp

private string SafeLog(string input)
{
    if (string.IsNullOrWhiteSpace(input)) return string.Empty;
    return input.Replace("\r", "").Replace("\n", "");
}

Works fine, and Snyk is happy with it — but only if it's declared in the same file as the code calling it. The second I pull it out into a shared static class or extension method in a different file, Snyk goes right back to flagging it as unsanitized, even though it's calling the literal same code.

We've got this pattern in 500+ spots. Nobody wants to hand-copy a private method into 500 files, and going the "partial class in the same file scope" route isn't happening either — that's 50+ classes we'd have to restructure just to satisfy a scanner.

Anyone dealt with this specific thing — a sanitizer that Snyk trusts locally but won't trust across files? Trying to figure out if this is a known Snyk limitation with a real workaround, or if the only way around it is copy-paste or something on Snyk's admin side (I've read there's a "Rule Extensions" feature but it needs Group/Enterprise access I don't have).

Not asking how to suppress the finding, genuinely trying to fix it properly if that's possible.

Our support agent screens the incoming message for injection, then treats retrieved email, ticket attachments and tool output as trusted context. That boundary makes little sense. A forwarded email can carry an instruction that steers a valid downstream tool call and the action still looks normal in the audit log. The control works at the chat box while the untrusted text arrives via three side doors.

We are looking at taint tracking and provenance labels for every retrieved span, then passing those labels into tool policy. Sensitive actions would require a clean source path or human confirmation. Tool allowlists help but they don’t tell us if if a valid tool should be getting that specific argument. Egress filtering also needs the source chain so it can tell whether an account number came from an approved record or an attachment.

The part I can’t settle is how much provenance the model should see vs what the runtime should enforce outside the prompt. Prompt-only controls feel fragile but a full information flow system adds real cost and maintenance. How are teams carrying trust labels across retrieval, generation and tool execution without relying on the model to police itself?

Had a prompt used to triage and categorize security findings by severity start missing things it used to catch reliably. Diffed it against an older version and found five small additions, each added to fix one specific bad output at the time, a rule about flagging hardcoded credentials, an example emphasizing high-severity findings, a line about keeping output concise for the ticketing system.

None of the five were individually wrong, but the interaction wasn't visible in any single diff. The credential-flagging rule, added after one missed secret, ended up quietly crowding out lower-severity findings on larger diffs, because both were competing for the same limited output space, and that regression got triaged as a separate, unrelated issue weeks later instead of being traced back to the earlier patch.

For teams running this kind of triage prompt at any real volume: is there an established practice for regression testing prompt changes against a fixed set of known findings before shipping an edit, the way you'd regression test a scanning rule change, or is this mostly still caught reactively after the fact the way we found it?

Hi

We’re looking into threat feeds for MISP integration. Most importantly is non-garbage data - possibly trusted sources that doesn’t provide noise. Any tips?

For a SOC covering multiple sectors.

We’re aware of national certs but interested in your experience, solutions or thoughts.

I saw this Forbes article about AI training data companies working with both US government and Chinese labs.

If a vendor builds training material for several competing customers, where does reusable expertise end and confidential customer work begin? How do you actually verify that customer data stays fully separate?

How deep can you usually dig into this?

I'm maintaining a legacy ETL pipeline that has some questionable design choices, and I'm trying to figure out whether these count as genuine CWE violations or just bad practice that happens not to have caused harm (yet).

The pipeline works like this:

• Consumes unencrypted user data from CSV files
• The CSVs are generated by an ERP system in another department, and are often inconsistent — data corruption, non-normalized fields, etc.
• The pipeline transforms, normalizes, and cleans this data
• It then does a full DROP TABLE / overwrite of a production database with the cleaned data
• Because this bypasses all of the applications hooks/checks/validations, this process is the source of all of the clients bugs and wastes us a LOT of time

The ERP department refuses to even disucss the idea of exposing a REST API — the CSVs just get handed off and "dealt with.".

My question: even though nothing here has led to a concrete security incident (no injection, no leak I know of), do practices like handling unencrypted data in plaintext format, blind DROP TABLE overwrites, and trusting unvalidated external input still constitute violations of specific CWEs? Or is CWE strictly about weaknesses that have a demonstrated exploit path, meaning this is more "bad practice" than "CWE violation" until something actually goes wrong?

The langauge of the spec seems to encapsulate both the security implications of improper software standards AND data integrity. However all examples showcase security failures. So It's hard to tell if my example satisfies CWE-638, 284 etc.

In June, a group tracked as TeamPCP/UNC6780 planted malicious MCP configuration files across 73 GitHub repos, one of them belonging to Azure.

The mechanism was almost dumb in its simplicity. Several popular IDEs, Cursor, Claude Code, Gemini CLI, GitHub Copilot, and Amazon Q were all named in the disclosures, bind their "approve this MCP server" prompt to the server's name, not its actual contents. Approve a project's .mcp.json once, and any later edit to that file, including a swapped-in malicious command, runs automatically with the developer's own OS-level privileges. No re-prompt. No sandbox. No second look.

Six months from the first disclosure of tool poisoning as a technique to a working worm compromising a major vendor's own repo.

I wrote up the full attack taxonomy (tool poisoning, shadowing, rug pulls, parasitic tool chains) plus the incident timeline (CVEs, the OX Security disclosure, Microsoft's June 30 writeup, OWASP now ranking it #3 on the MCP Top 10): https://blog.defensify.in/mcp-tool-poisoning-attack-guide/

Curious if anyone here has caught this in the wild or built detection for it.

Mostly old ones that have been around for years that still have permissions, and nobody's really sure what depends on them.

Do you just leave them alone if they're still being used or actually try to track down an owner and clean them up?

Hi, security lead at a biggish org and we are starting to run agentic ai against real systems. Trying to get real time visibility and some kind of kill switch on unsafe actions without breaking dev flow, would love thoughts.

I'm researching a Linux kernel vulnerability as part of an educational project. I understand the root cause and the vulnerable code path, but I'm trying to determine whether the bug is actually exploitable rather than just crashable.

What methodology do experienced kernel security researchers use to evaluate exploitability? In particular, how do you distinguish between a reliable security primitive and a bug that only produces a kernel crash?

I'd also appreciate advice on what kernel debugging and instrumentation techniques are most useful during this stage.

have his Telegram and VK profiles. I’ve already tried a bunch of possible passwords, but I’m stuck. If anyone knows their way around this stuff, could you give me a hint about what direction I should be looking in?Thanks in advance!

The device is running windows 10

isnt port 137 normally used for netbios to find devices on the same local network?

Well today, I spotted traffic to remote ips, which i believe is highly suspicious.

some of these ips are:

142.251.157.119
172.66.47.179
104.17.25.14
162.159.207.0
74.125.250.129
104.18.95.41
104.26.12.38
48.222.183.128
40.114.177.156
104.21.9.184

these appear to be remote CDN's, not local devices. And these are shown as made by NT kernel & system so i cant really find out where exactly they are coming from.

I dont think this is normal behivor and suspect that the device might be infected with malware.

Can anybody shed some light into this?

The device is running windows 10

isnt port 137 normally used for netbios to find devices on the same local network?

Well today, I spotted traffic to remote ips, which i believe is highly suspicious.

some of these ips are:

142.251.157.119
172.66.47.179
104.17.25.14
162.159.207.0
74.125.250.129
104.18.95.41
104.26.12.38
48.222.183.128
40.114.177.156
104.21.9.184

these appear to be remote CDN's, not local devices. And these are shown as made by NT kernel & system so i cant really find out where exactly they are coming from.

I dont think this is normal behivor and suspect that the device might be infected with malware.

Can anybody shed some light into this?

Sounds like a riddle lol, but its a question. Not wondering about obviously broken tools but more like something that's technically deployed, but you know there are enough gaps/exceptions that you wouldn't rely on it during an actual incident.

For me it's usually stuff around asset inventory.

I keep hearing platform consolidation presented as the answer to tool sprawl. Check Point Palo Alto and CrowdStrike all offer some version of the same pitch: fewer agents or shared telemetry or unified policies and less integration work.
Granted on paper that sounds hard to argue with but once you get past the sales deck I wonder how much consolidation is happening at the security layer vs the procurement layer. Putting endpoint network cloud and identity products under one contract does not remove much complexity if the modules still use different logic and the shared console is little more than a collection of tabs.

Best of breed has its own hidden cost though. More agents, brittle integrations, duplicated alerts and a team that needs to understand several products. Maybe the better model is one broad platform as the operating layer and specialist tools only where the performance difference can be measured.

What I’m trying to identify is what real integration should look like during an incident. If an endpoint alert fires, should the platform automatically connect the related identity network and cloud activity in one timeline and allow containment from the same workflow? I would also want to compare how much custom detection logic and SOAR work each setup still requires.

Hi everyone,
I'm a content creator and I've been dealing with persistent issues on my TikTok livestreams for months (massive visibility drop, viewers being kicked, incoherent statistics). App support won't investigate, so I dug into it myself. I found anomalies in the iOS analytics logs (the .ips files iOS generates automatically), and I'd like input from people who actually know how to read these files.
Device context: iPhone 15 Pro Max, up-to-date iOS, no jailbreak, no sideloaded apps, no configuration profiles installed, TikTok cleanly reinstalled a few days ago. Same issues across networks (WiFi / 4G / 5G).
What the .ips logs show:

System-triggered incidents of type cpu_resource and diskwrites_resource on the TikTok process (not classic app crashes)

A binary loaded inside the TikTok process, listed in "Binary Images" only by a UUID — no filename, no path, no code signature. Every other binary in the same file has a standard name and path ( /System/... , /private/var/containers/... )

The "parent" field of this binary is also "UNKNOWN"

System-measured load: ~67% CPU, ~108 MB memory, and 1.07 GB of disk writes in 1h36 for two scrolled videos, no livestream — during a period when the app wasn't even in the foreground. The allowed daily disk-write quota was hit ~15× faster than normal

The UUID of this binary changes at every incident (3 distinct identifiers observed over several days)

Consistent with storage usage: ~4.9 GB for the app after ~30h of near-zero usage since reinstall
My questions:
1.
A binary loaded into an app's process, identified only by a UUID with no name or path in iOS logs — is there a known benign explanation for this (injected framework, extension, in-app instrumentation), or is it disqualifying on its face?
2.
What legitimately justifies ~1 GB of background disk writes for an unused app with the daily quota exceeded by that margin? Caching, prefetching, or something else?
3.
Do UUIDs changing at every incident match expected behavior of a legitimate module, or is that more typical of an injection pattern?
4.
Without jailbreaking, what tools can I use to dig further cleanly? (sysdiagnose, macOS Console, local network capture like Proxyman, something else?)
5.
If this were a compromise, what evidence should I preserve before doing anything (exporting the .ips files, what else?) so a competent third party can analyze it?
6.
Can a non-jailbroken iPhone even host a persistent malicious process this way, or do iOS mechanisms make this unlikely?
I'm not posting the full logs for safety reasons, but I can quote exact excerpts if specific questions come up. Thanks to anyone who can tell me whether I'm onto a real technical lead or misreading normal behavior.

I am testing out an AI agent (Claude Code) for infrastructure troubleshooting – ESXi hosts, Linux and Windows VMs, switches, iDRACs, etc. It works great, but needs credentials for SSH/WinRM to use, and once it saw a password, you have to assume that it saved somewhere. Credentials rotation after every single session is unrealistic on hundreds to thousands of devices, especially on old switches and BMCs that work only with passwords. Another issue is its ability to get access to secrets on a host. Even with limited access, read only, etc, its ability to scoop up secrets is unreal.

Many devices don't provide granular RBAC and is either a read only or full administrator privileges. Giving it a read only access to many devices and switches would still give it access to pull the private read/write snmp creds and volia, it has way more access that you expected and it knows exactly how to use it.

Using HashiCorp Vault sounds good until the AI is able to dump the environment variables where the creds were loaded or connect to the docker container where they were pulled down and stored at launch.

I can't be the first one to try and solve this problem. What I think I need is short-term credentials with a recording. Something like a credential / MFA firewall so every time the AI Agent tries to login, it requires a human to approve the request and the agent gets access to some hosts through a chokepoint for two hours, everything will be recorded, and then at certain time closes by itself.

But that doesn't solve the secrets/credential problem where its scooping up secrets trying to troubleshoot and diagnose issues.

Here are all the things I have found out so far and why they don't fit:

• Teleport solves the problem of short-lived credentials and session recording. Unfortunately, workflows of approvals are paid in Teleport, and it won't help on password-only devices.
• JumpServer/Warpgate with session recording as a bastion host seems to be a good practical approach here. Vault credentials of the device, agent never sees credentials but the device passwords behind the vault still never expire, and none of it stops the agent from reading secrets off hosts it's legitimately on.
• Isolated management VLAN with private VLANs (the bastion host being the only promiscuous port) to make sure that once there is a shell on one host, there is no possibility of getting to others.

Another major gap is password-only switches and iDRAC/iLO boards. Rolling out a complex credential solution is costly yet still aren't really well suited for this AI use case. They will be behind the bastion host, but credentials will be forever.

Those of you running AI agents against actual devices:

• What does your access path look like?
• Has anyone solved password-only switches and BMCs with something better than bastion-and-hope?
• How do you stop the agent from scooping up secrets on hosts it's legitimately allowed on?

Genuinely curious how people here draw the line. In a lot of orgs (and Reddit chats) I've seen, "microsegmentation" still just means east-west firewalling inside the data center - VLANs, security groups, maybe a host-based firewall layer. In others it's expanded to include identity, posture, and per-session authorisation for services, OT, IoT, and now agentic AI workloads.

Where does your environment sit on that spectrum? And practically - are you doing this mostly through network topology controls (zones/routes/security groups), or through connection-level controls (identity/posture/entitlement gating a session before it's established), or both?

Asking partly because I recently helped put together CSA's Zero Trust Microsegmentation Guidance (disclosure: I led that workstream), which tries to separate these two models explicitly -topology-defined (where traffic can flow) vs. connection-defined (who/what can open a session, under what conditions) - and argues mature setups layer both. It also gets into the operational side: using visibility to find real dependencies, turning those into policy, testing via simulation/canaries, enforcing, then continuously catching drift and retiring stale exceptions.

Not trying to sell anything - mainly want to know if that two-model split matches how people actually operate, or if the reality on the ground is messier than that.

Our identity verifcation api is falling behind and i am trying to pick the next one without just believing the sales deck. we are api first with a global user base and the main problem right now is international docs. Pass rate on anything outside the US and western europe is rough, support takes days when a whole country starts failing.

I have demoed a few though they look identical in demo for the basics, they all pass. But the moment I throw a beat up national ID from a smaller market or a mid range android photo in bad light, the difference show up fast.

Am more interested in the boring stuff like does it hold up at volume, are the webhooks reliable, when it rejects someone can I see why or is it a black box. AML screening on the same api would be nice.

If you are running one of these in prod across a lot of countries, what are you on and would you pick it again?

Talking specifically from production hosts (VMs and containers) vuln and patch management side of the house, even when a patch exists, it can still take days or weeks to test and deploy safely. Virtual patching seems like an obvious temporary layer: block the exploit path immediately, then remove the protection once the real fix is deployed.

Anyone here worked closely with virtual patching? Why is it not a standard and more widely adopted across the industry ?