<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Composed Security on Medium]]></title>
        <description><![CDATA[Stories by Composed Security on Medium]]></description>
        <link>https://medium.com/@composedsecurity?source=rss-574e2fa24a9a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*wmulTGUU3StA9dcKiug4DA@2x.jpeg</url>
            <title>Stories by Composed Security on Medium</title>
            <link>https://medium.com/@composedsecurity?source=rss-574e2fa24a9a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 23:07:22 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@composedsecurity/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Google Wants to Eliminate Every Software Vulnerability. Here’s How.]]></title>
            <link>https://composedsecurity.medium.com/google-wants-to-eliminate-every-software-vulnerability-heres-how-bebf92171e83?source=rss-574e2fa24a9a------2</link>
            <guid isPermaLink="false">https://medium.com/p/bebf92171e83</guid>
            <dc:creator><![CDATA[Composed Security]]></dc:creator>
            <pubDate>Wed, 04 Mar 2026 08:17:47 GMT</pubDate>
            <atom:updated>2026-03-04T08:17:47.985Z</atom:updated>
            <content:encoded><![CDATA[<p>Based on the presentation “Evaluating Threats &amp; Automating Defense: How Google is Advancing Code Security” by Heather Adkins, VP Security Engineering at Google, and Four Flynn, VP Security and Privacy at Google DeepMind, delivered at [un]prompted: The AI Practitioner Conference.</p><p>Google opened their talk with one slide and one sentence:</p><blockquote>“Eliminate every software vulnerability on Earth. (And Mars, the Moon, etc…)”</blockquote><p>Sounds like a punchline. It isn’t.</p><p>What followed was a straightforward look at where autonomous code security is heading. If you run a security team, build security products, or depend on software that needs to not get hacked, this is worth understanding.</p><h3>The Target</h3><p>Google’s stated goal: by 202X, most of the software they create should be free of vulnerabilities. Not “reduced.” Not “better managed.” Free of them.</p><p>Getting there requires three things working together: finding vulnerabilities with precision and no noise, fixing them automatically and fast, and generating secure code by default before bugs enter the codebase at all.</p><h3>Big Sleep: The Vulnerability Hunter</h3><p>Big Sleep is Google’s agentic vulnerability discovery system. It’s not a scanner. It’s closer to a senior security researcher that never sleeps.</p><p>It takes in vulnerability context and target code, then runs a multi-turn LLM reasoning loop, forming and revising hypotheses the way a human researcher would. It has real tools available: a code browser, a Python interpreter, and a GDB debugger. When it finds something, it verifies the crash, generates a proof of vulnerability, and produces a high-quality report.</p><p>The hard requirement baked into the design: zero false positives. If you’ve worked with traditional SAST or DAST tools, you know why that matters. Noise kills adoption. Developers stop caring. Big Sleep is built so that when it flags something, it’s real.</p><h3>CodeMender: The Autonomous Fixer</h3><p>Finding bugs is one thing. Fixing them at scale without breaking anything is where most teams get stuck. CodeMender handles that.</p><p>A vulnerable codebase goes in. An LLM-based agent generates multiple candidate patches using root cause analysis and grounding. Each patch then runs through a rigorous validation pipeline: dynamic analysis with fuzzing and sanitizers, static analysis with formal verification, differential testing, and LLM judges that evaluate the quality of the fix.</p><p>Only the patch that passes everything becomes the final fix. No guessing, no shipping something half-checked.</p><h3>Secure by Default</h3><p>The third layer is about the developer experience. Google is training LLMs to generate secure code by default, so vulnerabilities don’t enter the codebase in the first place.</p><p>CodeMender runs proactively during development to harden code, and reactively post-merge to patch what slipped through. Big Sleep catches anything left standing. Together, they create a loop where the codebase gets more secure continuously, not just when someone schedules a quarterly audit.</p><h3>The Numbers</h3><p>This isn’t all theoretical. Google has already deployed these systems against open source software and logged 178 fixes in OSS, 48 patched and 130 hardened. They’ve automated hardening of LibWEBP via CodeMender and are expanding internally to codebases like Chrome.</p><p>They were also candid about the problems they’re still working through. How do you support OSS maintainers who are being flooded with AI-generated PRs? How do you redeploy auto-fixed code at scale without losing the trust of maintainers? Do you patch C++ or just rewrite it in Rust? No clean answers yet, but at least the right questions are on the table.</p><h3>What This Means for Your Team</h3><p>You don’t need Google’s research budget to take something useful from this.</p><p>Stop treating detection as the finish line. Discovery without remediation is just a longer backlog. The fix pipeline is where the actual value lives.</p><p>Precision matters more than volume. If your security tooling generates noise, engineers learn to ignore it. Zero false positives isn’t a luxury, it’s a product requirement.</p><p>Agentic reasoning loops are real and replicable. The multi-turn LLM plus toolset architecture that powers Big Sleep isn’t magic. If you’re building internal security tooling or evaluating vendors, ask whether they’re operating this way or still running single-pass static analysis from 2015.</p><p>Google put “eliminate every software vulnerability” on the board as a real engineering objective. Most of the tooling to get there is already running. The question for every security team is pretty simple: are you building toward that future, or waiting for it to arrive?</p><p>Credit: “Evaluating Threats &amp; Automating Defense: How Google is Advancing Code Security” by Heather Adkins and Four Flynn, presented at [un]prompted: The AI Practitioner Conference. Published by ComposedSecurity.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bebf92171e83" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From AI Prototype to Production: Why Verification-First AppSec Isn’t Optional Anymore]]></title>
            <link>https://composedsecurity.medium.com/from-ai-prototype-to-production-why-verification-first-appsec-isnt-optional-anymore-14ed5f2b86c2?source=rss-574e2fa24a9a------2</link>
            <guid isPermaLink="false">https://medium.com/p/14ed5f2b86c2</guid>
            <dc:creator><![CDATA[Composed Security]]></dc:creator>
            <pubDate>Sat, 28 Feb 2026 06:07:42 GMT</pubDate>
            <atom:updated>2026-02-28T06:07:42.764Z</atom:updated>
            <content:encoded><![CDATA[<p>There’s a moment every engineering team knows well.</p><p>The AI-powered feature demo crushes it in staging. Stakeholders are hyped. The Slack channel is popping. And then someone quietly asks: “Has this gone through security review?”</p><p>Crickets.</p><p>This is the prototype-to-production gap — and in 2026, it’s one of the most underestimated risk vectors in software development. Moving fast with AI is table stakes now. Moving safely with AI? That’s where teams keep stumbling.</p><p>Five things worth understanding before you ship that AI-generated code into the wild.</p><h4>1. AI-Generated Code Ships Vulnerabilities at Scale</h4><p><a href="https://www.veracode.com/blog/ai-generated-code-security-risks/">Veracode’s resea</a>rch puts security flaws in AI-generated code at roughly 45% of cases. Not a corner case — nearly half your pull requests.</p><p>The issue isn’t that LLMs write bad code. It’s that they write code that looks fine. Input validation that catches empty fields, but misses SQL injection. Auth flows that work great — until someone starts credential stuffing. Dependencies pulled from packages that were clean two years ago and quietly aren’t anymore.</p><p>LLMs optimize for patterns that worked. Production attackers hunt for edges that break. Those are very different games.</p><h4>2. The Prototype Environment Is a Lie</h4><p>Prototypes live in a bubble. Clean test data. No real users. No one actually trying to break things.</p><p>Production is the opposite of all of that.</p><p>The security assumptions woven into your prototype — that inputs are well-formed, that users behave, that your dependencies are current — unravel fast under real traffic. Whatever your staging environment isn’t testing, attackers will eventually test for you.</p><p>Think of your prototype as a threat model draft. Not a blueprint.</p><h4>3. Verification-First Means Security Left — Way Left</h4><p>“Shift left” has been the AppSec mantra for years. Verification-first goes further: bake verification into the design phase, not just the pipeline.</p><p>Every AI-generated code suggestion, every agent-triggered action — it should come with provenance. Where did this originate? What does it touch? What policy does it affect? That’s not overhead. That’s the minimum bar for trusting autonomous systems with production workloads.</p><p>In practice: treat every AI output as untrusted until validated. Wire SAST/DAST directly into CI/CD. Keep humans in the loop on high-risk code paths. Not because AI is bad at writing code — because it genuinely isn’t good at threat modeling.</p><h4>4. Agentic AI Blows Up the Traditional Attack Surface</h4><p>Agents — systems that act, not just generate — bring a threat surface that traditional AppSec tooling was never designed for.</p><p>T<a href="https://owasp.org/www-project-top-10-for-large-language-model-applications/">he OWASP LLM Top </a>10 flags prompt injection, excessive agency, and sensitive data leakage as the top vectors. None of these are theoretical. An unsecured agent with broad tool access can be manipulated into exfiltrating data, escalating privileges, or making irreversible API calls — all without a human ever approving the action.</p><p>Zero-trust isn’t just for networks anymore. Every agent action should be scoped, logged, and verifiable. If your AI agent can read a database, write to a filesystem, and call an external API — and none of that is gated — you haven’t deployed an assistant. You’ve deployed an attack surface.</p><h4>5. AI Security Debt Moves Faster Than Technical Debt</h4><p>Technical debt accumulates slowly. You can usually feel it building. AI-introduced security debt is different — it compounds quietly, through model drift, prompt template changes, dependency rot, and supply chain exposure you didn’t even know you inherited.</p><p>Teams staying ahead of this are already treating AI artifacts — models, prompts, weights — with the same version discipline they apply to first-party code. They’re running adversarial testing: prompt fuzzing, injection simulation, before anything hits production. They don’t treat security as a finishing gate. They treat it as the foundation everything else runs on.</p><p>Moving from AI prototype to production isn’t a deployment problem. It’s a trust problem.</p><p>The teams building verification into every layer — design, CI/CD, runtime — are the ones that won’t be writing incident postmortems six months from now.</p><p>Ship fast. Verify first.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=14ed5f2b86c2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[OpenClaw Is Viral. IronClaw Is What Comes After You Read the Security Reports.]]></title>
            <link>https://composedsecurity.medium.com/openclaw-is-viral-ironclaw-is-what-comes-after-you-read-the-security-reports-7c43bbf07b86?source=rss-574e2fa24a9a------2</link>
            <guid isPermaLink="false">https://medium.com/p/7c43bbf07b86</guid>
            <dc:creator><![CDATA[Composed Security]]></dc:creator>
            <pubDate>Sun, 22 Feb 2026 11:01:19 GMT</pubDate>
            <atom:updated>2026-02-23T01:28:44.279Z</atom:updated>
            <content:encoded><![CDATA[<p>OpenClaw had 60,000 GitHub stars in 72 hours. By February it crossed 190,000 — faster than Kubernetes, faster than anything in open source history. Then the security reports started landing.</p><p><a href="https://censys.com/blog/openclaw-in-the-wild-mapping-the-public-exposure-of-a-viral-ai-assistant">Censys</a> found 21,000+ OpenClaw instances accidentally exposed to the public internet. VirusTotal flagged hundreds of malicious community skills — credential theft, crypto draining, command injection — with a single actor uploading 300 in 72 hours. <a href="https://www.wired.com/story/malevolent-ai-agent-openclaw-clawdbot/">Wired</a> ran “I Loved My OpenClaw AI Agent — Until It Turned on Me.” J<a href="https://www.linkedin.com/posts/jasoncalacanis_is-the-only-way-to-keep-openclaw-secure-to-activity-7428241827855659008-ZUpI">ason Calacanis</a> asked publicly whether sandboxing everything was the only fix.</p><p>The demand was validated. The architecture was not. That gap is what IronClaw was built to close.</p><h4>The Threat Model OpenClaw Ignores</h4><p>A chatbot answers questions. An autonomous AI agent acts — reading your email, writing files, making HTTP requests, running shell commands. <strong>Every one of those actions is a potential attack vector</strong>. All four of these attack classes — malicious skill exfiltrating credentials, prompt injection hijacking agent actions, backdoored plugin harvesting API keys, misconfigured instance exposed to the internet — happened in the OpenClaw ecosystem within weeks of launch.<strong><em> Not theoretical. Documented.</em></strong></p><p>OpenClaw was built to be impressive. It was not built assuming it would be attacked.</p><h4>IronClaw’s Core Assumption: You Will Be Compromised</h4><p>IronClaw is a Rust reimplementation of OpenClaw built by NEAR AI. Same vision — local personal AI agent, messaging integrations, workflow automation — but a radically different security premise. The design assumption isn’t “keep bad things out.” It’s “bad things will get in. How do we contain the blast radius?” That shift drives every architectural decision.</p><h4>Every Tool Call Is an Attack Surface</h4><p>In most agent frameworks, tools run in the same process as the agent with the same permissions. IronClaw sandboxes every tool in a WebAssembly (WASM) container — the most significant security innovation in the project and something OpenClaw simply does not have.</p><p>Capability-based permissions: tools get<strong> deny-all by default</strong>. HTTP access, secret access, tool invocation — each requires explicit opt-in. Endpoint allowlisting means even with HTTP capability, tools can only reach approved hosts and paths — no beaconing to attacker-controlled servers. Credentials are never passed into the WASM sandbox; they’re injected after the request is validated, so the tool code never sees your API keys. Every request and response is scanned for secret exfiltration in both directions.</p><p>The pipeline: WASM tool → Allowlist check → Leak scan → Credential injection → Execute → Leak scan → Response. A malicious tool has to defeat every layer.</p><h4>Network Profiles and Per-Context Control</h4><p>OpenClaw’s HTTP server binds to 0.0.0.0 by default — the exact configuration gap that exposed 21,000+ users. IronClaw ships with configurable network profiles: loopback-only, LAN, or remote. Network exposure is an explicit opt-in, not a default. On top of this, per-group tool policies mean your agent can run with different permission sets depending on the channel — your personal Telegram DM gets different access than a shared Slack workspace.</p><h4>Prompt Injection Is a First-Class Threat</h4><p>When your agent reads external content — a webpage, email, document — that content enters the LLM context. A malicious payload saying “ignore previous instructions” can hijack the agent’s next action. IronClaw addresses this with pattern-based detection, content sanitization, policy rules with severity levels (Block/Warn/Review/Sanitize), and tool output wrapping that labels external content so it can’t masquerade as system instructions. It’s not a perfect defense — nothing is — but it’s <strong>defense-in-depth rather than blind trust.</strong></p><h4>The Rust Advantage</h4><p>IronClaw is written in Rust — and this isn’t just a performance story, it’s a security story. Entire classes of memory vulnerabilities possible in OpenClaw’s TypeScript/Node runtime simply don’t exist at the language level in Rust. It also ships as a single binary with no npm dependency tree — eliminating the supply chain attack surface that comes with thousands of transitive JavaScript packages.</p><h4>What IronClaw Is Not (Yet)</h4><p>The feature parity gap with OpenClaw is real. OpenClaw supports WhatsApp, Discord, Signal, iMessage, and a dozen other platforms; IronClaw currently covers Telegram, Slack, and HTTP webhooks. No mobile apps. A much smaller community skill ecosystem. If you need maximum integration breadth today, OpenClaw is the more capable product. If you need an agent you can trust with credentials, private communications, and business workflows, IronClaw is the one worth trusting with keys to your kingdom.</p><h4>The Bottom Line</h4><p><strong><em>Autonomy without security isn’t a feature. It’s a liability.</em></strong> IronClaw is what the agentic AI wave looks like when you design for the day you get compromised — not just the day everything works. WASM sandboxing. Credential isolation. Prompt injection defense. Network profiles. Per-context tool policies. Zero telemetry. AES-256-GCM encrypted local storage.</p><p><strong><em>OpenClaw proved people want this. IronClaw is built for people who can’t afford for it to go wrong.</em></strong></p><p><strong><em>GitHub: </em></strong><a href="https://github.com/nearai/ironclaw"><strong><em>github.com/nearai/ironcl</em></strong></a><strong><em>aw</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7c43bbf07b86" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Security Review Must Happen in Pull Requests — Not After Merge]]></title>
            <link>https://composedsecurity.medium.com/why-security-review-must-happen-in-pull-requests-not-after-merge-192d3059ec08?source=rss-574e2fa24a9a------2</link>
            <guid isPermaLink="false">https://medium.com/p/192d3059ec08</guid>
            <dc:creator><![CDATA[Composed Security]]></dc:creator>
            <pubDate>Mon, 16 Feb 2026 20:04:54 GMT</pubDate>
            <atom:updated>2026-02-17T09:07:44.490Z</atom:updated>
            <content:encoded><![CDATA[<p>AI coding accelerates development, but PRs remain the last checkpoint before deploy. Learn why security review must shift left into pull requests to catch risks traditional SAST tools miss.</p><p>Development velocity doubled with AI coding. PRs are flying through. But security review time? Still flat.</p><p>That bottleneck isn’t going away. What can change is whether security makes it into the conversation before code ships.</p><h3>The PR is Your Last Checkpoint</h3><p>Once code merges to main, it’s headed to production. Traditional SAST tools scan after merge — when fixing issues means opening new PRs, re-reviewing code, and delaying releases.</p><p>The cost of waiting:</p><p>• Security findings become backlog items instead of blockers<br>• Developers context-switch away from the code they just wrote<br>• “Ship now, fix later” becomes the default</p><p>PR-based security flips this. When your security tool comments directly on the pull request, vulnerabilities get caught while the code is still in review — before anyone clicks merge.</p><h3>What Makes PR Security Different</h3><p>Traditional SAST runs in CI/CD pipelines after code is already committed. PR security tools run during code review, surfacing issues as inline comments on the exact lines that need fixing.</p><p>The difference:</p><p>Traditional SAST: Scan → Report → Backlog → Context loss<br>PR Security: Scan → Inline comment → Fix → Merge clean</p><p>Developers don’t have to leave GitHub. Security findings appear alongside code review feedback, making them part of the conversation instead of an afterthought.</p><h3>Real-World Impact</h3><p>Before PR security:<br>A developer introduces an SQL injection vulnerability. It merges to main. SAST flags it two days later. The developer is now working on a different feature. Security team files a ticket. The fix gets prioritized for “next sprint.”</p><p>With PR security:<br>The same SQL injection gets flagged in the PR. The developer sees it immediately, fixes it in the same session, and the code merges clean. No ticket. No sprint delay. No vulnerability in production.</p><h3>How to Implement PR Security</h3><p>Shifting security into PRs doesn’t require ripping out your existing tools. Start with these steps:</p><p>1. Choose a PR-native security tool<br>Look for tools that integrate directly with GitHub/GitLab and comment on pull requests. Avoid tools that only generate reports or require separate dashboards.</p><p>2. Start with high-severity findings<br>Don’t overwhelm developers with every possible issue. Configure your tool to block PRs only for critical and high-severity vulnerabilities.</p><p>3. Make security findings actionable<br>The best PR security tools don’t just flag problems — they suggest fixes. Look for tools that provide remediation guidance or even auto-fix options.</p><p>4. Track what matters<br>Measure time-to-fix for vulnerabilities found in PRs vs. post-merge. You’ll see the difference immediately.</p><h3>The Bottom Line</h3><p>AI coding tools are making developers faster. But speed without security is technical debt at scale.</p><p>PR-based security review ensures vulnerabilities get caught while code is still in draft — when fixing them is fast, cheap, and doesn’t derail your release schedule.</p><p>If your security tools are still scanning after merge, you’re already too late.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=192d3059ec08" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[MVSC-Core: Minimum Viable Secure Code (v0.1)]]></title>
            <link>https://composedsecurity.medium.com/mvsc-core-minimum-viable-secure-code-v0-1-37e728896071?source=rss-574e2fa24a9a------2</link>
            <guid isPermaLink="false">https://medium.com/p/37e728896071</guid>
            <dc:creator><![CDATA[Composed Security]]></dc:creator>
            <pubDate>Mon, 02 Feb 2026 08:13:39 GMT</pubDate>
            <atom:updated>2026-02-02T08:40:12.108Z</atom:updated>
            <content:encoded><![CDATA[<p>Compliance frameworks like <a href="https://mvsp.dev/">MVSP (Minimum Viable Secure Product)</a> are great for proving your organization is enterprise-ready and for unblocking bigger goals like vendor reviews, SOC 2 / ISO work, and landing your next serious customer.</p><p>But when you’re staring at a pull request (or reviewing code generated by an AI agent), you don’t need more paperwork — you need a baseline that catches the bugs that actually ship.</p><p>MVSC (Minimum Viable Secure Code) is that baseline: short, language-agnostic, and designed to pass the sniff test.<br>You can also drop it into a system prompt, an agent “skill,” or an agents.md file to nudge your favorite dev agent into producing code that’s at least defensible by default.</p><h3>The MVSC-Core baseline (14 rules)</h3><p>This list is intentionally a trimmed, high-signal subset of <a href="https://owasp.org/www-project-secure-coding-practices-quick-reference-guide/">OWASP Secure Coding Practices </a>(so it’s boring in the right way).</p><p><strong>1) MVSC-CORE-01 — Define trust boundaries<br></strong>Identify trusted vs untrusted sources (clients, DBs, files, downstream APIs) and validate anything untrusted.</p><p><strong>2) MVSC-CORE-02 — Server-side validation only<br></strong>Do all input validation on a trusted system; client checks are UX, not security.</p><p><strong>3) MVSC-CORE-03 — Allowlist validation, reject on failure<br></strong>Validate expected types with allowlists (not denylists), validate length and range, canonicalize/normalize before validating, and reject invalid input.</p><p>4) MVSC-CORE-04 — Contextual output encoding<br>Encode output on a trusted system using standard routines, per output context, with explicit charsets (e.g., UTF‑8).</p><p><strong>5) MVSC-CORE-05 — Parameterized DB access only<br></strong>Use strongly typed parameterized queries and least-privilege DB accounts.</p><p><strong>6) MVSC-CORE-06 — Centralize authentication and fail securely<br></strong>Require authentication for protected resources, enforce it on a trusted system, use standard services where possible, and fail securely.</p><p><strong>7) MVSC-CORE-07 — Store credentials correctly<br></strong>If you store passwords, use cryptographically strong one-way salted hashes and do it server-side.</p><p><strong>8) MVSC-CORE-08 — Session tokens are secrets<br></strong>Generate session IDs server-side, use vetted randomness, terminate sessions on logout, and never expose session IDs in URLs, logs, or error messages.</p><p><strong>9) MVSC-CORE-09 — Authorization is per-request and server-side<br></strong>Make authorization decisions with trusted server-side objects, enforce authz on every request, and deny by default if security configuration can’t be loaded.</p><p><strong>10) MVSC-CORE-10 — Crypto is not DIY<br></strong>Use approved crypto libraries and crypto-grade RNG for tokens/IDs, and have an actual key management process.</p><p><strong>11) MVSC-CORE-11 — Sensitive data stays out of URLs, logs, and client storage<br></strong>Do not put sensitive data in HTTP GET parameters, don’t store secrets in cleartext client-side, and purge temporary server-side copies when no longer needed.</p><p><strong>12) MVSC-CORE-12 — TLS for sensitive data, never downgrade<br></strong>Use TLS for authenticated/sensitive content, keep certs valid, and do not fall back to insecure connections on failure.</p><p><strong>13) MVSC-CORE-13 — Safe errors and useful logs<br></strong>Don’t leak stack traces/session IDs/secrets in errors; log validation failures, auth attempts (especially failures), and access control failures; keep log access restricted.</p><p><strong>14) MVSC-CORE-14 — Treat “fetch a URL” as privileged (SSRF-class)<br></strong>Any server-side URL fetch/tool-call must be constrained, because SSRF is explicitly called out as a Top 10 web risk (A10).</p><h3>Copy/paste: agents.md (sniff-test mode)</h3><p>Use this to steer a coding agent without turning your prompts into a novel.</p><p># agents.md</p><p>## MVSC-Core v0.1</p><p>Fetch the complete spec:<br>```<br>curl -o mvsc-core.md <a href="https://raw.githubusercontent.com/composedsecurity/mvsc-core/main/README.md">https://raw.githubusercontent.com/composedsecurity/mvsc-core/main/README.md</a><br>```</p><p>Then reference MVSC-CORE-01 through MVSC-CORE-14 during code generation.</p><p>Full spec: <a href="https://github.com/composedsecurity/mvsc-core">https://github.com/composedsecurity/mvsc-core</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=37e728896071" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[OWASP Top 10 for Large Language Models]]></title>
            <link>https://composedsecurity.medium.com/owasp-top-10-for-large-language-models-e857fc4ebfa4?source=rss-574e2fa24a9a------2</link>
            <guid isPermaLink="false">https://medium.com/p/e857fc4ebfa4</guid>
            <dc:creator><![CDATA[Composed Security]]></dc:creator>
            <pubDate>Mon, 11 Dec 2023 22:42:05 GMT</pubDate>
            <atom:updated>2023-12-12T07:32:32.536Z</atom:updated>
            <content:encoded><![CDATA[<p>The evolving nature of security challenges in world with AI requires a multi-disciplinary approach involving expertise in machine learning, cybersecurity, and software engineering. Understanding these vulnerabilities is crucial for both development and security operations teams to effectively secure LLMs and their surrounding ecosystems.</p><ol><li><strong>Prompt Injection (LLM01)</strong>: Much like classic injection attacks, the ability to manipulate the behavior of LLMs through crafted input remains a top concern. It shows that traditional security issues remain relevant in new technology domains.</li><li><strong>Insecure Output Handling (LLM02)</strong>: The potential for XSS, SSRF, and other traditional attacks via LLM output indicates the need for strict output filtering, aligning closely with classic web application concerns.</li><li><strong>Training Data Poisoning (LLM03)</strong>: This is an entirely new category specific to machine learning models and highlights the significance of the data used for training. Data integrity is critical for the security, effectiveness, and accuracy of LLMs.</li><li><strong>Model Denial of Service (LLM04)</strong>: LLM-specific DoS attacks can be resource-intensive, and it’s essential to understand the capacity limits of both input and output to mitigate this risk.</li><li><strong>Supply Chain Vulnerabilities (LLM05)</strong>: This shows the broader ecosystem dependencies and how security extends beyond just the code and into third-party components, training data, and even deprecated models.</li><li><strong>Sensitive Information Disclosure (LLM06):</strong> As with traditional applications, proper data sanitization and understanding the internals of the model are crucial to prevent unintended data leakage.</li><li><strong>Insecure Plug-in Design (LLM07):</strong> Plugins extend the functionality but also the attack surface, introducing new vulnerabilities like remote code execution.</li><li><strong>Excessive Agency (LLM08):</strong> Least privilege remains a fundamental security principle, now applied to machine learning agents and plugins.</li><li><strong>Overreliance (LLM09):</strong> This introduces risks not just at a technical but also at a strategic level, affecting decision-making and possibly introducing security vulnerabilities if the model output is trusted unquestioningly.</li><li><strong>Model Theft (LLM10):</strong> This is akin to intellectual property theft but in the realm of machine learning, affecting both the integrity and confidentiality of the model and potentially exposing sensitive data.</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e857fc4ebfa4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding and Securing Our Interconnected Digital World]]></title>
            <link>https://composedsecurity.medium.com/how-to-api-security-0cfd9e711a33?source=rss-574e2fa24a9a------2</link>
            <guid isPermaLink="false">https://medium.com/p/0cfd9e711a33</guid>
            <category><![CDATA[api-security]]></category>
            <dc:creator><![CDATA[Composed Security]]></dc:creator>
            <pubDate>Mon, 20 Nov 2023 17:10:58 GMT</pubDate>
            <atom:updated>2023-12-12T07:53:19.721Z</atom:updated>
            <content:encoded><![CDATA[<h3>The Mesh of Modern Technology</h3><p>Have you ever paused to think about how websites, mobile phones, apps, digital assistants, and smart home technologies manage to work so seamlessly together? This intricate mesh of technology has not just simplified our lives but also raised important questions about communication and security in the digital realm. How do these diverse systems understand each other, and more importantly, are they safeguarded against threats?</p><h3>The Role of APIs in a Connected World</h3><p>At the heart of this interconnectedness are Application Programming Interfaces (APIs). APIs are the unsung heroes that allow different software systems to communicate, share data, and understand each other. They’re the reason you can see real-time weather updates on your phone, control smart home devices through an app, or seamlessly integrate your social media feeds into various platforms.</p><h3>The Security Challenge</h3><p>However, with this convenience comes a significant challenge: security. As APIs become more prevalent, they also become attractive targets for malicious attacks. The consequences of compromised API security can range from data breaches and unauthorized access to service disruptions and compromised end-user privacy.</p><h3>OWASP Top 10 for APIs</h3><p>To address these challenges, the Open Web Application Security Project (OWASP) has identified the top 10 most common and impactful security risks affecting APIs. This list is not just a guideline but a blueprint for securing the very threads that hold our digital ecosystem together. Let’s explore these risks and their remediations:</p><ol><li>Broken Object Level Authorization (API1): Ensure that users can only access objects they are authorized for. Robust access control mechanisms and regular security testing are key.</li><li>Broken Authentication (API2): Implement strong authentication protocols like OAuth, JWTs, or OpenID Connect to reliably verify user identities.</li><li>Excessive Data Exposure (API3): Employ careful data filtering on the server-side to prevent sensitive data from being exposed to unauthorized users.</li><li>Lack of Resources &amp; Rate Limiting (API4): Rate limiting and throttling control the number of requests a user can send, protecting against denial-of-service attacks.</li><li>Broken Function Level Authorization (API5): Similar to object-level authorization, ensure users can only access functions they’re authorized for.</li><li>Mass Assignment (API6): Prevent attackers from exploiting object properties by strictly defining what data can be updated through APIs.</li><li>Security Misconfiguration (API7): Regular audits and updates to API and network configurations can significantly reduce this risk.</li><li>Injection (API8): Rigorous input validation and prepared statements are essential to protect against injection attacks.</li><li>Improper Assets Management (API9): Properly documenting and managing APIs, especially in development and testing environments, is crucial.</li><li>Insufficient Logging &amp; Monitoring (API10): Comprehensive logging and real-time monitoring systems enable the early detection and response to security incidents.</li></ol><p>Additional Measures for Comprehensive Security</p><ul><li>CORS Policy: Proper configuration is essential to prevent unauthorized API interactions.</li><li>Incident Response Plan: A well-defined plan is crucial for efficient response to security incidents.</li><li>Educate and Train: Continuous education and training ensure that your team is aware of best practices and the latest security threats.</li><li>Compliance and Standards: Adherence to compliance requirements and security standards is fundamental for a secure API ecosystem.</li></ul><h4>Conclusion</h4><p>Aligning your security measures with the OWASP Top 10 for APIs is a strategic approach to safeguarding your digital assets. By understanding and implementing these remediation steps, you can significantly reduce the risk of vulnerabilities and build a robust, secure API environment.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0cfd9e711a33" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Streamlining Acceptance Criteria for Secure Agile Development]]></title>
            <link>https://composedsecurity.medium.com/streamlining-acceptance-criteria-for-secure-agile-development-310975266f37?source=rss-574e2fa24a9a------2</link>
            <guid isPermaLink="false">https://medium.com/p/310975266f37</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[application-security]]></category>
            <category><![CDATA[product-security]]></category>
            <category><![CDATA[security-architecture]]></category>
            <category><![CDATA[secure-coding]]></category>
            <dc:creator><![CDATA[Composed Security]]></dc:creator>
            <pubDate>Sat, 11 Nov 2023 00:01:55 GMT</pubDate>
            <atom:updated>2023-11-11T00:01:55.151Z</atom:updated>
            <content:encoded><![CDATA[<p>Clear and concise acceptance criteria are essential for secure Agile software development in a Secure Software Factory. They ensure user stories are both functional and secure.</p><p>Here’s a brief guide to crafting these criteria effectively and be agile not ‘fragile’.</p><p><strong>1. Understand User Stories</strong>: Grasp the core of each user story, focusing on security aspects in line with the OWASP Top 10.</p><p><strong>2. Specific and Measurable:</strong> Set specific, measurable criteria, e.g., “System resists SQL injection attacks,” instead of vague security goals.</p><p><strong>3. Embed Security Early:</strong> Incorporate security elements like coding practices, data encryption, and access controls right from the start.</p><p><strong>4. Simplicity and Feasibility:</strong> Ensure criteria are straightforward and achievable within a sprint’s scope.</p><p><strong>5. Checklist Format:</strong> Use a checklist for clarity, e.g.:</p><ul><li>SANS Penetration Testing Checklist</li><li>OWASP-ASVS.</li><li>NIST 800–53</li></ul><p><strong>6. Team Collaboration</strong>: Involve developers, security experts, and QA in creating and reviewing criteria.</p><p><strong>7. Evolve with Threats:</strong> Regularly update criteria to align with new security challenges.</p><p>Conclusion: Effective acceptance criteria balance clarity and security, guiding Agile teams to develop software that’s both functional and secure.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=310975266f37" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Application Security: Wut?]]></title>
            <link>https://composedsecurity.medium.com/application-security-wut-6cae9f1b90a8?source=rss-574e2fa24a9a------2</link>
            <guid isPermaLink="false">https://medium.com/p/6cae9f1b90a8</guid>
            <category><![CDATA[application-modernization]]></category>
            <category><![CDATA[application-development]]></category>
            <category><![CDATA[application-security]]></category>
            <category><![CDATA[application-architecture]]></category>
            <dc:creator><![CDATA[Composed Security]]></dc:creator>
            <pubDate>Fri, 06 Oct 2023 16:13:31 GMT</pubDate>
            <atom:updated>2023-12-02T07:21:03.017Z</atom:updated>
            <content:encoded><![CDATA[<h3>Navigating the Vital Realm of Application Security: A Comprehensive Introduction</h3><p>In our software-driven business era, Application Security (AppSec) has transcended the status of a mere buzzword to become a cornerstone in the cybersecurity landscape. Understanding the gravity of AppSec is now paramount for CxOs, as even a minor code error could expose businesses to risks akin to significant firewall breaches. But what is AppSec, and why is it an essential yet challenging component in the machinery of modern business? Let’s explore.</p><p><strong>Defining Application Security</strong>: At its core, Application Security acts as the sentinel guarding your business’s technological lifeline. It encompasses the protection of web and mobile applications, APIs, IoT applications, and even legacy systems — essentially, the unique digital concoctions that empower your business. AppSec’s role is twofold: ensuring these vital assets operate flawlessly and maintaining their security and compliance with industry standards.</p><p>Renowned CTO of Cigital, Inc., Gary McGraw, analogizes, “Building secure applications is akin to constructing a bank vault; you wouldn’t use tissue paper.”</p><p><strong>The Lifecycle Perspective</strong></p><p>AppSec is not a one-time endeavor; it is a perpetual commitment spanning your software’s entire lifecycle — from design to decommissioning. It represents a continuous dedication to secure innovation.</p><p><strong>The Challenges of AppSec:</strong></p><ol><li><strong>The Dynamic Nature of Applications:</strong> Businesses are in constant flux, much like rivers. With frequent updates and new features, maintaining up-to-date security is an unending challenge.</li><li><strong>A Diverse Developer Landscape:</strong> Today’s development teams are a tapestry of diverse skills and backgrounds. This diversity, while a strength, necessitates universally comprehensible and implementable security protocols.</li><li><strong>The Human Element:</strong> Security transcends code. It’s equally about the developers — their cognitive biases, overconfidence, or simple human errors can sometimes be the weakest link.</li><li><strong>Evolving Threat Landscape:</strong> The ever-evolving nature of cyber threats turns security into a relentless pursuit, demanding sophisticated logging and real-time monitoring for prompt detection and response.</li></ol><p><strong>Foundational Principles of Effective AppSec:</strong> There’s no universal blueprint for AppSec, but certain fundamental principles can guide organizations in crafting a robust strategy. Our upcoming posts will delve into these principles, offering actionable insights to strengthen your software’s security posture.</p><p><strong>Looking Ahead: A Thrilling Future for AppSec:</strong> Brace yourselves! The future of AppSec promises to be an exhilarating journey. As the digital world expands, so does AppSec’s scope — encompassing Artificial Intelligence, Machine Learning, API Security, and Cloud Computing. These advancements are set to redefine how we safeguard our digital treasures.</p><p>Stay Tuned for More! Join us in our subsequent posts as we continue to unravel the complexities and advancements in the realm of Application Security &amp; Artificial Intelligence. The journey is just beginning!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6cae9f1b90a8" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>