r/devsecops • • Apr 22 '26

After claude mythos , do you think any detection company will survive?

0 Upvotes

Mythos being so good at detecting vulnerabilities made me wonder what actually is coming up for the industry?


r/devsecops • • May 01 '26

Does it still worth to learn IAC, Scripting in the era of AI?

0 Upvotes

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 • • Jun 25 '26

An SBOM is just a claim. I built a way to turn it into verifiable evidence — looking for holes in the model

0 Upvotes

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 • • Mar 30 '26

Do dev teams actually fix security issues or just ignore dashboards?

0 Upvotes

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 • • Feb 04 '26

My team should be renamed to talkops

1 Upvotes

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 • • Aug 20 '26

Everyone's talking about the Snowflake CI/CD vulnerability. The most dangerous CI/CD vulnerability is the one nobody has found yet

0 Upvotes

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 • • Sep 04 '26

How to secure SSH and Postgres with Warpgate

Thumbnail
packagemain.tech
0 Upvotes

r/devsecops • • May 22 '25

what is an MCP and why should I care

0 Upvotes

)


r/devsecops • • Aug 27 '25

What even is DevSecAI? The mashup we all need.

Thumbnail reddit.com
0 Upvotes

r/devsecops • • Sep 19 '24

DevSecOps Doubt

0 Upvotes

Can you be DevSecOps without knowing how to program?


r/devsecops • • Dec 08 '22

Secure Code Training/Codebashing

0 Upvotes

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 • • Jan 10 '25

This Akido tool disgusts me....they don't do any real work except to package scanning tools together using other vendors

6 Upvotes

There's no real improvement to the test results....


r/devsecops • • 17h ago

I got tired of scanners that dump 400 findings and never prove one. So I built one that tries to exploit them live.

0 Upvotes

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 • • Oct 26 '24

Just discovered something for beginners like me in Cybersecurity

1 Upvotes

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 • • Nov 21 '22

DevOps Vs DevSecOps: Similarities and Key Differences

Thumbnail
solutelabs.com
1 Upvotes

r/devsecops • • Jul 18 '25

Caught a major SQL injection vulnerability right before launch — shifting security left in DevOps actually saved us

4 Upvotes

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:

👉 https://devsecopsai.today/i-shifted-security-left-in-devops-and-caught-a-major-breach-just-before-launch-the-sql-injection-1cee5baf6ba0

Anyone else here practicing security-first DevOps or running security gates early in your workflows?


r/devsecops • • Mar 05 '25

ECED Certification devsecops is it WORTH IT!!!!

0 Upvotes

Hello friends i hope you are doing ok im just asking if Ec council devsecops engineer certification is wroth it


r/devsecops • • Jul 22 '26

I built an IaC auditor that scores cost and security in the same pass - and tells you which to fix first when they conflict

0 Upvotes

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/month

Details 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 • • Feb 02 '25

PTaaS Solution

0 Upvotes

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 • • Jun 25 '20

Cloud Security Alliance Announces Availability Of Key Cloud Security Assessment

0 Upvotes

Read about the latest Cloud Security Alliance.


r/devsecops • • Oct 21 '24

Securing 4C's of a Software Product - AWS Edition

0 Upvotes

🌟 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. 🔐

ProductSecurity #KubernetesSecurity #DockerSecurity #CloudNativeSecurity #DevSecOps #AWSIAM #ContainerSecurity #CloudSecurity #GitHubActions #SecretsManagement #SAST #OpenSourceSecurity


r/devsecops • • Oct 01 '25

When 99.9% SLA sounds good… until you do the math

0 Upvotes

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 • • Jul 26 '26

Our pipeline runs four different security scanners. They agree on almost nothing. We built an ID scheme to fix that

0 Upvotes

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.)


r/devsecops • • Aug 03 '22

Where to start with DevSecOps

Thumbnail
nsirap.com
1 Upvotes