r/devsecops • u/h33terbot • Apr 22 '26
After claude mythos , do you think any detection company will survive?
Mythos being so good at detecting vulnerabilities made me wonder what actually is coming up for the industry?
r/devsecops • u/h33terbot • Apr 22 '26
Mythos being so good at detecting vulnerabilities made me wonder what actually is coming up for the industry?
r/devsecops • u/Overall-Associate-31 • May 01 '26
Hi everyone,
brief overview of my background I am a junior DevOps engineer and I have the basics of scripting and IAC, but when i want to automate something i always repeatedly refer to the docs which consumes a lot of time, So I have been thinking lately about AI and its ability to generate clean, reusable scripts (python, bash, PowerShell) and i though is it an intelligent move to not learn scripting and IAC and stick only with the logic without bothering myself with the syntax.
i really want to hear your opinion about this.
r/devsecops • u/nextgenrails • Jun 25 '26
Been chewing on this problem for a while: an SBOM is basically an unsigned assertion. It's a JSON file that says "here's what's in my software," and everyone downstream — auditors, primes, customers — is expected to take it on faith.
There's no built-in way to prove the SBOM you're showing someone today matches what you actually shipped, or what you claimed six months ago.
That gap gets real in regulated work. A CMMC Level 2 contractor doesn't just need to generate an SBOM, they need to be able to demonstrate composition state to an assessor in a way that doesn't boil down to "trust our scanner output."
So I built a verification layer and I want people here to poke holes in it.
The mechanism: you submit a CycloneDX or SPDX manifest (it also takes VS Code extension lists and AI model cards) and it issues a signed receipt — RS256 JWS with a SHA-384 Merkle root committing to the normalized component set.
The receipt proves exactly what the manifest contained at issuance. Anyone can verify it offline against the published public key, no account, and the manifest itself is processed in memory and discarded rather than stored.
A couple of things that fall out of that design:
You can take a receipt issued months ago and re-evaluate the original component list against current OSV/NVD/GHSA data without holding onto the original manifest — the component set is committed in the receipt, so you re-check the same set against today's vulnerability picture. And you can diff two receipts to see exactly what changed between builds: added, removed, upgraded components, plus the change in risk.
Key handling is the part I'd most want torn apart: keys rotate on a schedule, retired keys still verify historical receipts (so old proofs don't break), and the public keyset history is hashed and timestamped via OpenTimestamps so the key lineage itself is tamper-evident. Custody is honest in the docs — keys live server-side, not in an HSM, and I say so rather than implying hardware backing.
Where I think the obvious objections are, and I'd rather hear yours: it's still a centralized issuer, so you're trusting me as the signer. The anchoring is on the keyset history, not per-receipt. And the whole thing only matters if "portable, independently verifiable proof of composition state" is actually a need people have, versus a nice-to-have that loses to just re-running a scanner.
So that's my real question for this sub — if you've dealt with SBOMs in a compliance or supply-chain context: is signed, independently verifiable composition state something that solves a problem for you, or is there a reason you'd stick with what you already run? I'd genuinely rather hear the critical version than the polite one.
Site's cbomcompliance.com if you want to actually break it — there's a free tier that issues real receipts so you can verify one yourself.
r/devsecops • u/Consistent_Ad5248 • Mar 30 '26
Honest question — in your org, do developers actually act on security findings?
In a couple of setups I’ve seen:
- dashboards are full of vulnerabilities
- alerts keep increasing
- but very few issues actually get fixed
Feels like:
either prioritization is broken
or the feedback loop is too slow
How are you making security actionable for dev teams?
Genuinely curious what’s working in real environments
r/devsecops • u/SpinMoney • Feb 04 '26
Some days I spend more time talking about reliability than actually improving it.
Standups, syncs, postmortems, pre-mortems, planning, re-planning, alignment calls... and by the time I get a quiet hour, I'm already drained.
get that communication matters, but at some point the work needs focus.
How do you protect deep work time without looking "unavailable"?
r/devsecops • u/DavidPulaski • Aug 20 '26
Everyone is focused on the fact that a researcher found and exploited a vulnerability in Snowflake's GitHub Actions workflow.
But finding it wasn't the interesting part.
The interesting part is that the vulnerability already existed before anyone knew it was there.
That's the uncomfortable reality of modern software delivery. We spend a lot of time talking about known vulnerabilities, discovered vulnerabilities, patched vulnerabilities, and CVEs. Attackers only need the vulnerabilities that haven't been discovered yet.
As AI accelerates both software development and security research, teams are creating and uncovering issues faster than ever. That's useful, but it doesn't solve the fundamental problem:
What protects a build pipeline from the risks nobody has identified yet?
I'm starting to think the industry may be over-indexed on detection and under-invested in prevention.
Instead of asking, "Can we find every risky condition?", maybe we should also be asking:
Can a workflow make unexpected outbound connections?
Can it access resources it shouldn't?
Can it download and execute untrusted code?
Can it exfiltrate secrets?
Can it perform actions outside its intended scope?
If those behaviors are blocked by default, the specific vulnerability matters a lot less.
Full disclosure: I work for InvisiRisk, a company focused on build pipeline security, so I have some bias here. That said, I think the architectural question stands on its own.
Curious how others here think about this. Are you relying primarily on scanning, detections, and reviews, or are you putting preventive controls directly into your CI/CD pipelines?
r/devsecops • u/der_gopher • Sep 04 '26
r/devsecops • u/devsecai • Aug 27 '25
r/devsecops • u/GasInternational3733 • Sep 19 '24
Can you be DevSecOps without knowing how to program?
r/devsecops • u/AlexBDM-Codebashing • Dec 08 '22
Hello Fam, Christmas is just around the corner and cyber attacks are scaling, I work with a Training Solution that comes in a gamified way.
if someone would like to know more about it please let me know!
Alejandro Cervantes - Codebashing
r/devsecops • u/IamOkei • Jan 10 '25
There's no real improvement to the test results....
r/devsecops • u/bgbe_ • 17h ago
I've spent 10+ years in security. The pattern that wore me down is the scanner that hands you a wall of "possible" issues and leaves triage to you.
So I built a tool around one idea: a finding isn't done until it has a verdict.
- Scan: SAST, dependencies, secrets, IaC, container images, licenses. The scanner runs locally. SCA lookups send package and CVE identifiers only, never your code.
- Prove: for the classes that allow it (command injection, XSS, open redirect, boolean-blind SQLi, XXE), it fires a reviewed PoC at your running app in a sandbox. Each class was tested against a real vulnerable sink and a real negative control, to check it doesn't cry wolf.
- Fix: it patches vulnerable dependencies across 8 ecosystems and re-scans or re-exploits to confirm the fix worked.
- Scope gate: anything that sends traffic needs a human-approved scope file. Missing file means it refuses to run, so it never fails open.
Benchmarks. Scored against each app's own answer key, not by counting findings:
- On 10 deliberately vulnerable open-source apps in 5 languages, it found 92 of 167 labelled issues. A leading commercial SAST tool found 72 and GitHub CodeQL found 68.
- On OWASP BenchmarkPython it scored 58.5 against that tool's 27.5. We lose two classes there (command injection and code injection), and we flag more safe cases (15.2% false-positive rate vs 10.3%).
Caveats:
- These are training apps, not your codebase.
- We wrote rules after seeing what these apps exposed, so this is not a blind test.
- Java is our weakest language.
The most useful thing I learned is that testing the tester finds real bugs. One of my own "negative controls" turned out to be a genuine auth bug, so the harness reported a false positive. Another harness read a fully booted target as "not ready" and burned 10 minutes every run. Both are fixed.
I'm looking for people who run AppSec, or an MSP covering clients, to try it on a real repo and tell me where it's wrong. [OFFER: e.g. "free scan of one repo, DM me" or "free tier at verdictruntime.com"]
Happy to answer anything, including where it's weak. And show a demo
r/devsecops • u/Frosty-Champion7811 • Oct 26 '24
I wanted to share something that really helped me on my journey into cybersecurity. I was super excited but also felt pretty lost. There’s just so much to learn it was really overwhelming. I stumbled upon a Roadmap guide from AppSecEngineer and it was a total game-changer for me! I realized everything now made sense. It showed me exactly what I should focus on and what more to learn. I totally recommend checking THIS out!
r/devsecops • u/likhithak55 • Nov 21 '22
r/devsecops • u/ChocolateDry2241 • Jul 18 '25
I used to treat security like a final checklist item you know, one of those "we’ll scan everything before go-live" kind of deals.
But on one recent project, I decided to shift security left: integrate checks early into the CI/CD pipeline, static code scanning, and even peer review with a security lens.
What happened? We found a SQL injection bug that could’ve exposed user data — just days before launch. If we hadn't caught it, it would’ve gone to prod.
I documented everything in a post: the mistake, the fix, and how shifting left in DevOps saved us. Might be helpful if you're thinking about baking security into your pipeline:
Anyone else here practicing security-first DevOps or running security gates early in your workflows?
r/devsecops • u/Key_Elk_8528 • Mar 05 '25
Hello friends i hope you are doing ok im just asking if Ec council devsecops engineer certification is wroth it
r/devsecops • u/tarrun_1 • Jul 22 '26
I'm the author - this is an MIT-licensed tool I've been building, and I'd like feedback from people who actually run this stuff.
The problem I kept hitting: our security scanner flagged an over-permissive security group, and our cost tooling flagged the same box as over-provisioned. Both correct. But if you right-size first, you've reduced the cost of running a machine that's still wide open. Nothing in our toolchain understood the ordering.
So Cairn does one pass over Terraform and scores four lenses : security, cost, reliability, governance, then reconciles them. When findings collide on the same resource, it emits a trade-off block telling you to sequence the security fix first. It also emits the patch (the actual line to change), not just a rule ID.
Concrete output from a scan of a deliberately-bad stack:
Cairn found 25 issue(s) in examples/vulnerable (6 cost, 6 governance, 3 reliability, 10 security)
1. [CRITICAL/SECURITY] aws_security_group.web (SEC001)
problem: Ingress on port 22 is open to the entire internet (0.0.0.0/0)
patch: cidr_blocks = ["10.0.0.0/8"]
Trade-offs (cost x risk on the same resource):
aws_db_instance.main [COST + GOVERNANCE + RELIABILITY + SECURITY]
Sequence the security fix first, then right-size — resizing an exposed
resource first just makes the breach cheaper to run.
Estimated recoverable spend: ~$1,717.53/monthDetails that matter to this sub:
Local only. No account, no telemetry, zero network calls. --explain (LLM) is opt-in, BYO key, and refuses any non-HTTPS base URL that isn't loopback.
42 rules across AWS, Azure, GCP, Kubernetes, on-prem vSphere. If a provider has no rules, it reports "not scanned" instead of a misleading "clean".
Writes fixes. cairn fix --apply is whitelist-only, refuses to run on a dirty git worktree, dry-run by default, and records before/after hashes.
SARIF output for GitHub code scanning, plus JSON/HTML/Markdown.
Python 3.10+, pip install cairn-iac, MIT.
Honest limitations: it's v0.6.0. Cost figures are estimates from an offline price book, not your actual bill. Terraform is the deepest target; Kubernetes is 6 rules. It doesn't read cloud state (there's a drift command but you feed it terraform show -json yourself ; no credentials).
Repo: https://github.com/cairn-oss/cairn
What I'd most like: point it at real Terraform and tell me what it gets wrong. False positives are the fastest way to make it better.
r/devsecops • u/drreview2020 • Feb 02 '25
I heard there are SaaS-based PTaaS (Penetration Testing as a Service) applications that let users perform their own penetration tests. Is that correct? I believed that an effective penetration test should consist of at least 70% manual testing and 30% automated testing. I'd like to get your thoughts since this info came from someone senior in my company, who may not be entirely knowledgeable.
r/devsecops • u/snoopy477 • Jun 25 '20
Read about the latest Cloud Security Alliance.
r/devsecops • u/salecharohit • Oct 21 '24
🌟 Open Sourcing my training 'Securing the 4C's of a Software Product'! 🚀 Check it out: https://www.rohitsalecha.com/s4cp/
Learn how to secure Code, Containers, Clusters, and Cloud ☁️ through a defensive approach by bootstrapping security into your entire stack. 🔐
r/devsecops • u/majesticace4 • Oct 01 '25
Had an interesting conversation last week about a potential enterprise deal. The idea was floated to promise 99.9% uptime as part of the SLA. On the surface it sounded fine, everyone in the room nodded along.
Then I did the math: 99.9% translates to about 43 minutes of downtime per month. The awkward part? We'd already used that up during a P1 incident the previous Saturday. I ended up being the one to point it out, and the room went dead silent.
What really made me shake my head was when someone suggested maybe we should aim for 99.99% instead, just to grab the deal. To me, adding another feels absurd when we can barely keep up with the three nines.
In the end, we dropped the idea of including the SLA for this account, but it definitely could have gone the other way.
Curious if anyone else has had to be the "reality check" in one of these conversations?
r/devsecops • u/SelectionBitter6821 • Jul 26 '26
I'm a DevSecOps engineer, and this is the exact version of a problem I hit at work, not something I noticed from the outside.
Run SAST, SCA, and an AI-agent-specific scanner across the same codebase, and you'd expect some redundancy. What you actually get is worse: the same underlying issue, flagged by two different tools, with two completely different names and no way to tell your pipeline they're the same finding. Multiply that across a real CI/CD setup with several tools chained together, and triage turns into manually reconciling naming conventions instead of fixing anything.
This isn't a new problem in general. A SQL injection gets a CVE ID, maps to a CWE category, and every tool in the pipeline that finds it points at the same reference. That's exactly what makes cross-tool correlation possible for conventional vulnerabilities.
Agentic AI components (MCP servers, agent skills, LLM plugins) had nothing like that, for a real structural reason: CVE needs a package and version to attach to, CWE describes code-level weakness patterns, and neither has a vocabulary for a behavioral pattern that isn't tied to either.
So a few of us built AVE (Agentic Vulnerability Enumeration): an open standard giving these classes stable IDs, the same way CVE does, so a finding from one tool can actually be compared against a finding from another.
What's in it: 59 records, each a distinct behavioral class. Severity scored with OWASP's own AIVSS framework. Crosswalked into OWASP's MCP Top 10, the Agentic Security Initiative Top 10, and MITRE ATLAS, plus AVE-in-SARIF, so IDs ride directly into GitHub's own Security tab and CI output without any custom tooling. Apache 2.0.
The part that actually convinced me this holds up outside our own tooling: a completely independent developer built a static config-file auditor, sharing no code with anything we wrote, crosswalked his own findings against AVE's taxonomy, and tested it directly against our scanner on the same files. The large majority of overlapping findings came back with the identical ID, unprompted.
If you're dealing with the same multi-scanner reconciliation problem, in this space or a completely different one, I'd like to hear how you're handling it, and where this looks wrong or incomplete.
Repo: github.com/aveproject/ave
Site: aveproject.org
(Disclosure: I'm one of the people building this.)