标签：#SEC

In 1995, Netscape released SSL. The web didn't really take off commercially until then. Before SSL, you couldn't trust a website with your credit card. After SSL, e-commerce exploded. AI agents are at the same inflection point in 2026. Here's why. The problem Agents are starting to call each other autonomously. Each hop is a trust decision. But agents have no way to verify each other. Today, when Agent A calls Agent B: Is Agent B who it claims to be? No way to verify Has Agent B been audited for security? No standard Has Agent B's key been compromised? No revocation mechanism This is exactly where the web was in 1994. No SSL, no trust, no commerce. The analogy Web (1995) Agents (2026) HTTP (transport) A2A + MCP (transport) No HTTPS = can't trust No ATC = can't trust SSL certificate ATC Trust Card Certificate Authority MarketNow Sentinel CA Revocation list (CRL) /api/atc?action=verify What I built ATC (Agent Trust Card) — SSL certificates for AI agents. How it works Agent registers with MarketNow CA CA signs the agent's identity with Ed25519 Agent presents its ATC to other agents Other agents verify the signature with the CA public key If compromised, the CA revokes the ATC Real cryptography (not a mock) Ed25519 signatures (RFC 8032) CA private key in Vercel env var (never exposed) CA public key committed to public GitHub repo Every ATC persisted as signed JSON in _data/atc/ Anyone can verify signatures offline using crypto.verify Sentinel integration The ATC's trust score comes from Sentinel — the 8-layer security audit pipeline: L1.5: metadata checks L1.6: Semgrep + secrets + OSV L1.7: binary/malware detection L1.8: malware family signatures (Emotet, Cobalt Strike, etc.) The positioning MarketNow is not competing with A2A or MCP. It's the trust layer that sits on top: ATC (Trust Layer) <- MarketNow A2A / MCP (Transport Layer) <- Google / Anthropic HTTP / WebSocket (Network) <- Standard Every agent with an A2A card can have an ATC Trust Card. Every MCP skill can hav

Seventy-three comments into the thread, someone asked a question my gate had no answer for: what happens when the proposer walks past a claim it should have surfaced? The system could catch what the model said wrong. It could not catch what the model chose not to say. That absence looked identical to clean compliance — no trace, no alarm, nothing to review. The silence was invisible. Earlier this week I published the hard limit of my memory gate. The system could detect direction changes in authority — a real source used to support a claim it never made. The relation-span clause killed a citation-shaped class of lie. Labels lagged, but boundaries held. The result was real, and I said so. I also said where it stopped working. The thread that followed broke it open in ways I could not see from the inside. The gap they found The gate watched what the proposer said . If a model claimed an authority changed, the confirmer checked the span. If the claim was wrong, the confirmer rejected it. If the claim was shaped like a citation but pointed at nothing real, the gate caught it. What the gate could not do was catch what the proposer chose not to say . nexus-lab-zen named it. If the proposer walks past a claim it should have surfaced, the artifact looks identical to clean compliance. There is no trace of the inspection that did not happen. The absence is invisible. I built the first answer: a silent-omission gate that diffs the proposer's emissions against an independent observer's footprint. If an outside watcher saw a surface the proposer never mentioned, the system fires undeclared_surface . Eight frozen cases, independently recomputed, shipped public ( f41ee0f ). But nexus came back. Instead of observing the proposer's footprint after the fact, make the proposer declare what it inspected before the diff runs. A typed "surfaces considered" set, emitted alongside proposals. Then silence splits into two states you can actually store: "I looked at X and chose not to surface

On July 14, 2026, the Linux Foundation stood up the x402 Foundation — neutral governance for the protocol that lets AI agents pay each other over HTTP 402. The member list is the entire payments industry: Visa, Mastercard, Amex, Stripe, AWS, Google, Cloudflare, Coinbase, Circle, Ripple, Shopify, and two dozen more. Read the launch release end to end and one thing is missing. There is no conformance suite. No security profile. No certification program. No validation procedure. The industry just gave agent payments a standards home and standardized the rails — not the proof that the payment an agent executed was the one it was authorized to make. This is a pattern, not a one-off. Standards bodies standardize the protocol. The conformance surface lags — and the security surface lags behind that. It happened with MCP. The protocol matured fast; the testing of it arrived later and is still catching up. It is happening again with x402, on a compressed timeline, with more money behind it. The gap matters because a signed, well-formed record is not the same thing as a true one. Look at what landed in the research this month. ShareLock (arXiv 2606.27027 , Liu et al., June 2026) distributes a malicious instruction as benign-looking secret shares across several MCP tool descriptions using a Shamir threshold scheme. Each fragment passes per-tool inspection. The payload reconstructs only when the shares are aggregated, after a quiet trigger during a server update. The paper reports an average attack success rate above 90% against tool-description detectors. Every individual record was valid. The composite was hostile. A conformance check that validates each tool description in isolation passes the whole attack straight through. That is the shape of the coming problem for agent payments. Signed receipts, content-addressed evidence records, canonicalized envelopes — the industry is converging on the format of trustworthy agent evidence fast, and getting that format ratified inside

Ask any engineering manager whether their team pastes code into ChatGPT and you'll get a nervous laugh. The honest answer is constantly — a stack trace here, a config file there, "just cleaning up this SQL." Most of it is harmless. Some of it carries an AWS key, a database password, or a customer's PII straight to a third-party model. I've spent the last while looking at how teams try to control this, and most of the common approaches quietly fail. Here's what doesn't work, what does, and why. Why this isn't a normal DLP problem Traditional DLP watches email, file shares, and cloud storage. An AI prompt leak skips all of them: the data goes from a browser tab to an AI provider's API over HTTPS and never touches the channels legacy DLP inspects. It's also invisible after the fact. Once a prompt is sent there's no sent-mail copy, no uploaded-file record. If you didn't catch it at the moment of submission, you have no idea it happened. Prevention has to live in the browser , or it doesn't happen at all. The approaches that don't hold up Blocking AI tools outright. Employees just switch to their phone or a personal laptop. You lose the productivity and keep the risk. Network proxies / CASBs. They can see the domain but struggle to inspect encrypted prompt content without heavy MITM infrastructure — and they don't understand a DOCX dropped into a chat window. Policy + training. Sets expectations, stops nothing in the moment. Post-hoc SaaS scanners. Find the exposure after the data already left. Good for audit, useless for prevention. What actually works: intercept in the browser The only place you can reliably read a prompt is where it's typed. A managed browser extension can patch the page's network calls, read the prompt (and any attached files) before they send, scan against your DLP rules, and block anything that matches — all client-side, in well under a second, with no proxy and no rerouted traffic. That's the model I've become convinced is right, and it's the appr

Originally published at daniel-yang.com . I've been using passkeys for a while now, and at some point I noticed an extension in the WebAuthn spec that almost nobody talks about: PRF. It lets a website ask your authenticator to evaluate a pseudo-random function during login. Deterministic output, 32 bytes, keyed to that specific credential, never leaves your browser. That's an encryption key. Sitting inside the same ceremony everyone already uses for login. So I built pknotes to see how far the idea goes: an end-to-end encrypted notes app with no master password anywhere. Your passkey unlocks your notes in the literal, cryptographic sense. This post is the architecture writeup. There's a live demo if you'd rather poke it first (notes wiped daily). One ceremony, two jobs A normal passkey login proves who you are and nothing else. With the PRF extension, the same ceremony does double duty: The server verifies the WebAuthn assertion. That's login. The client reads the PRF output from the same response and derives a key from it. That's decryption. The server never sees the PRF bytes. They're returned to client-side JavaScript only, after user verification (Face ID, Touch ID, PIN), and only for the requesting origin. Requesting it looks like this: const credential = await navigator . credentials . get ({ publicKey : { challenge , userVerification : ' required ' , extensions : { prf : { eval : { first : new TextEncoder (). encode ( ' pknotes/prf-eval/v1 ' ) } }, }, }, }); const prfOutput = credential . getClientExtensionResults (). prf . results . first ; // 32 bytes, deterministic for this credential + this input, never sent anywhere The key hierarchy Raw PRF output shouldn't encrypt data directly, and you also want to be able to add and remove devices without re-encrypting everything. So there's a small hierarchy: Passkey PRF output │ HKDF-SHA256 ▼ KEK (key-encryption key, exists only in browser memory) │ unwraps ▼ Master key (random AES-256, generated once at signup) │

Coca Cola said dairy production at its Fairlife unit will "remain suspended" in the United States following a hack.

The social-engineering technique has primarily been a tool of financially motivated criminals.

Amazon Web Services has recently introduced AWS Continuum, a new integrated security platform to automate the discovery, enforcement, and remediation of security issues across codebases, dependencies, and applications. AWS Continuum launches with four agentic capabilities, aiming at the entire vulnerability lifecycle: penetration testing, code review, threat modelling, and code vulnerabilities. By Gianmarco Nalin

The Problem If you’ve built a decent-sized NestJS application, you know the authorization dance. You start with basic Roles, then suddenly you need fine-grained permissions, then maybe some attribute-based access control (ABAC). Before you know it, your controllers are cluttered with @UseGuards(RolesGuard) , and your RolesGuard itself is a massive switch statement checking for every possible permission string. It's repetitive, hard to test, and honestly, a bit boring to maintain. The Solution: nestjs-permissions I got tired of reinventing this logic for every project, so I built nestjs-permissions . The goal was simple: Declarative, type-safe authorization that stays out of your way while keeping your code clean. Why use it? Decorator-Driven: No more complex metadata injection. Just wrap your routes. Type-Safe: Keep your permissions consistent across your frontend and backend. Framework-Native: It plays nicely with the standard NestJS Request lifecycle. Quick Start Getting started takes about 5 minutes. 1. Install it: npm install nestjs - permissions 2. Configure your module: import { Module } from ' @nestjs/common ' ; import { PermissionsModule } from ' nestjs-permissions ' ; @ Module ({ imports : [ PermissionsModule . register ({ // Your config here }) ], }) export class AppModule {} 3. Protect your routes: import { Get , Controller } from ' @nestjs/common ' ; import { RequirePermissions } from ' nestjs-permissions ' ; @ Controller ( ' dashboard ' ) export class DashboardController { @ Get ( ' admin ' ) @ RequirePermissions ( ' admin.read ' ) async getDashboard () { return ' Secret Admin Data ' ; } } What’s Under the Hood? Under the hood, nestjs-permissions leverages the NestJS Reflector to cleanly extract metadata from your route handlers. It automatically taps into the execution context, checking the incoming request against the required permissions without forcing you to write boilerplate guards for every module. When NOT to use it If you need hyper-complex, at

Most "I built a home SOC" posts show you the pretty dashboard and stop there. This one is about what happened after the dashboard loaded — because that's where the real learning was. 🖥️ The setup Three Mac Minis, one control machine, all Ubuntu. Mac Mini 1 runs the Wazuh manager, indexer, and dashboard — the security monitoring core. Mac Mini 2 handles AWS IAM permission scanning (Cloudsplaining, ScoutSuite). Mac Mini 3 is a documentation hub plus a custom vulnerability-intelligence pipeline pulling from the NVD API and NIST's CPRT compliance framework data. A fourth machine, my daily driver, orchestrates all three over SSH. Today's goal: get every machine reporting into Wazuh, so I'd have real, fleet-wide visibility — not just a single monitored box. 🐛 Bug #1: the silent feed stall After installing the Wazuh agent on Mac Mini 3, vulnerability scanning just... sat there. The log showed Initiating update feed process and then nothing. No error, no timeout, no progress. I ruled things out methodically: DNS resolved fine, curl could reach Wazuh's CTI feed endpoint and complete a full TLS handshake, disk space was nowhere close to full, and there were no stale lock files sitting around. Every individual piece of the pipeline worked in isolation — but the feed download itself never completed. The actual fix: upgrade Wazuh from 4.14.5 to 4.14.6. A newer point release fixed whatever was silently stalling the content-updater module. Once upgraded, the feed downloaded, decompressed, and the scanner came alive within minutes. Lesson: when every individual network/system check passes but a specific module still won't progress, check for a version-specific bug before going deeper down the debugging rabbit hole. 🔒 Bug #2: locking myself out with fail2ban Mid-troubleshooting, my control machine's SSH connection to Mac Mini 3 started getting flatly refused — no prompt, no error, just Connection refused. Ping worked fine. Every other port responded. Just port 22, silently dead. fai

Owen Flowers and Thalha Jubair, two members of the prolific Scattered Spider hacking group, pleaded guilty and were sentenced to five years and six months in jail for hacking London’s metropolitan transit system.

One period tracker app tested by Mozilla was 'squeaky clean,' while another app was seen sharing users' health data with an analytics company, underscoring vast differences in user privacy among these apps.

Your Test Data May Be More Dangerous Than Your Production Database Most organizations protect production databases carefully. Access is restricted, activity is logged, and security teams monitor unusual behavior. Then a copy of the same data is exported into a test environment, sent to an analytics team, or shared with an outside service provider. At that moment, the protection model often becomes much weaker. The copied database may contain customer names, phone numbers, account details, identification numbers, medical information, transaction histories, or internal employee records. Developers may need realistic data structures, but they rarely need to see the real identities behind them. Operations teams may need to investigate a production issue, but they do not always require full access to sensitive fields. This is where data masking becomes a practical security control. It allows useful data to remain available while reducing the exposure of the people and organizations represented inside it. The Real Risk Begins When Data Starts Moving Sensitive data rarely stays in one place. It flows from production into testing, development, quality assurance, reporting, analytics, migration projects, outsourced support, and third party platforms. Every new copy expands the attack surface. A production database may have strong access controls, but a test database may be managed by a broader team. A temporary migration environment may remain online longer than planned. A dataset shared for analytics may contain fields that were not necessary for the project. The security problem is therefore larger than database access. It is about controlling what information remains visible as data moves through the organization. Data masking changes sensitive values while preserving their structure and usefulness. A masked phone number can still look like a phone number. A substituted customer name can still support application testing. A shuffled account value can preserve distribution

GDPR Compliance Fails When It Exists Only in Policy Documents Many organizations can produce a privacy policy, a data processing register, and a set of security procedures. The harder question is whether their infrastructure can actually protect, recover, trace, and report personal data when something goes wrong. GDPR compliance is often discussed as a legal project. In practice, many of its most difficult requirements depend on everyday IT operations. Can the organization recover personal data after a destructive incident? Can it identify who restored, copied, accessed, or deleted a backup? Can it detect suspicious activity quickly enough to support an investigation? Can it demonstrate that protection controls are applied across on premises, cloud, and hybrid environments? Policies explain intent. Operational controls provide evidence. Availability Is a Privacy Requirement Too Privacy discussions often focus on unauthorized access and disclosure. Data loss and prolonged unavailability matter as well. Personal data may become unavailable because of ransomware, storage failure, accidental deletion, database corruption, software defects, or a regional outage. If the organization cannot restore that data, it may be unable to serve customers, respond to data subject requests, or maintain essential business processes. A GDPR aligned protection strategy should therefore include reliable backup, offsite copies, tested recovery, and resilience across multiple failure scenarios. The backup architecture should support the systems that actually contain personal data, including databases, virtual machines, file servers, object storage, cloud workloads, and large data platforms. Protecting only the most visible applications leaves hidden gaps. Encryption Is Necessary, but It Is Not the Whole Answer Encryption protects data during transmission and storage, especially when backup copies move across networks or are stored outside the production environment. However, encrypted data

Drawing on more than a decade spent helping build some of the world's most influential AI systems, including research that later informed the development of ChatGPT, Andrew Dai explains why he believes visual AI is one of the next major frontiers in artificial intelligence.

* When a project first starts, CI/CD pipelines are usually simple. * Build the application. Run a few tests. Deploy somewhere. Done. Then six months pass. Another test gets added. Then another deployment step. A security scan. Performance tests. Notifications. More environments. Before long, a pipeline that once took five minutes now takes forty-five. I've seen this happen more than once, and it's rarely because Azure DevOps is the problem. It's usually because nobody ever stops to ask one simple question: Does this step still belong here? Everything Ends Up in the Same Pipeline One of the most common mistakes I see is trying to make a single pipeline do everything. Every Pull Request ends up running: Every unit test Every API test Hundreds of UI tests Security scans Deployment steps Report generation The result? Developers wait longer for feedback, releases become slower, and people eventually start ignoring failed pipelines because they happen too often. Fast Feedback Wins Not every test needs to run on every commit. A better approach is to think about the purpose of each pipeline. For a Pull Request, I want answers quickly. That usually means: Build the application Run unit tests Run a small smoke test suite Stop if something important fails Everything else can happen later. Long-running regression tests, cross-browser testing and other expensive checks are often better suited to scheduled or nightly pipelines. Pipelines Should Evolve A pipeline isn't something you build once and forget about. Every few months it's worth reviewing it. Ask yourself: Which step takes the longest? Which tests fail most often? Are there any tasks nobody remembers adding? Are we getting useful feedback, or just more output? Removing unnecessary work is just as valuable as adding new automation. Final Thoughts Azure DevOps is an incredibly powerful platform, but even the best tools become frustrating if they're overloaded with unnecessary work. The goal isn't to build the biggest pipel

MCP for AWS Security Engineers: Build a Read-Only Security Hub Triage Agent For AWS-heavy security work, I would start with AWS Agent Toolkit for AWS and the managed AWS MCP Server , not a custom MCP server. The reason is practical. AWS now provides a managed MCP path that can connect AI coding agents to AWS documentation, AWS APIs, AWS skills, and existing IAM credentials. The Agent Toolkit also provides plugin-based setup for supported agents such as Claude Code and Codex. For security teams, that is the right starting point because the enforcement point remains AWS IAM, not the model. The initial operating model should be strict: Read-only first. No production write authority. No access to secrets. No raw customer PII or sensitive incident logs in prompt context. No automatic remediation. No AI-approved suppression, exception, merge, deploy, or risk acceptance. Human review and CI/CD remain the release authority. That is the same posture I would use for a governed Claude Code or Codex rollout: named identities, SSO, scoped credentials, default deny, tool approval, audit logs, and security evidence tied back to tickets, pull requests, CI logs, and cloud findings. What we are building This article walks through a practical security workflow: A read-only Security Hub triage assistant that helps a junior security engineer produce a daily or weekly findings summary, remediation backlog, and evidence pack without allowing the agent to modify AWS. The agent will be able to: Read AWS Security Hub findings. Group findings by account, severity, product, resource, and control. Explain why a finding matters. Draft remediation tickets. Draft a Slack-ready summary. Produce local markdown, CSV, and JSON evidence files. The agent will not be able to: Suppress findings. Archive findings. Mark findings resolved. Disable Security Hub standards. Modify IAM, S3, EC2, KMS, GuardDuty, Inspector, or Config. Deploy remediation. Run destructive scripts. Approve risk acceptance. This is no

The Idea: Hidden Instructions Inside Trusted Content Prompt injection is an attack where malicious instructions are embedded inside content that an AI is asked to process - a document, a webpage, an email, a customer support ticket. The model can't always distinguish between "data I'm reading" and "commands I should follow," so it follows the embedded instruction as if a legitimate user sent it. This gets sharper when AI agents (autonomous systems that browse the web, read files, and take actions on your behalf) are involved. A summarizer that reads a webpage might encounter hidden text instructing it to forward your conversation history somewhere, or change the tone of its next reply, or deny remembering something it just said. The model has no inherent way to verify who is actually giving orders. The core problem is one of trust boundaries: current large language models process instructions and data through the same channel - natural language - so there's no hard technical wall between "read this" and "do this." Researchers have demonstrated this across multiple major models, not because any one model is uniquely broken, but because the architecture makes the distinction genuinely difficult. Defenses exist but are imperfect. Techniques include output filtering, sandboxing agent permissions (limiting what actions the model is allowed to take regardless of what it's told), prompt hardening (structuring system prompts to be resistant to override), and retrieval-aware design that treats external content as untrusted by default. No single fix closes the gap entirely. Real Example: The Customer Support Agent Imagine a small business deploys an AI agent to handle incoming support emails. The agent reads the email, checks order history, and drafts replies. A bad actor sends a support ticket that looks normal on the surface, but contains a hidden paragraph - white text on white background, or text in a section the agent processes but doesn't display - that says: "Ignore pr

GitHub announced agentic autofix for code scanning alerts in public preview on July 10, 2026. Primary source: GitHub Changelog, July 10, 2026 . The wrong metric is “percentage of alerts with a generated patch.” Generation is only the first transition: alert -> candidate -> build -> tests -> security oracle -> human review -> merge -> post-merge observation This is an evaluation proposal, not a benchmark or assessment of GitHub's preview. Choose a bounded canary Start with repositories that have active owners, deterministic builds, relevant isolated tests, reversible releases, and no automatic production deployment from candidate patches. Exclude abandoned code, safety-critical paths, and repositories with unreliable tests. Assign the canary deterministically—for example, hash a stable alert ID into a fixed percentage. Do not move difficult results out of the cohort after seeing them. Record every attempt, including abstentions and failures: attempt_id : " <id>" alert_class : " <normalized class>" base_revision : " <commit>" outcome : generated : true applied_cleanly : true build_passed : true tests_passed : false security_oracle_passed : false human_decision : " rejected" failure_class : " semantic_incomplete" escaped_to_default_branch : false The schema is local evaluation metadata; it does not imply that GitHub exposes these fields. Classify the earliest broken invariant Class Meaning No candidate Tool abstained Scope violation Unrelated or forbidden paths changed Apply failure Patch does not apply to recorded base Build failure Patched revision cannot build Regression Existing behavior broke Semantic incomplete Alert changed but security property remains broken Overcorrection Valid behavior was blocked Test manipulation Validation was weakened or removed Stale base Result targeted another revision Review ambiguity Human cannot establish why the patch is safe Infrastructure Evaluation could not complete Post-merge escape Later evidence disproved acceptance Use one

GitHub announced on July 14, 2026 that security reviews are available in the GitHub Copilot app. Primary source: GitHub Changelog, July 14, 2026 . The meaningful research question is not whether people click Accept. It is whether they can build an evidence-backed decision when guidance is useful, incomplete, or wrong. understand change -> inspect evidence -> challenge findings -> verify uncertainty -> accept, reject, or escalate This is a proposed research protocol, not a completed study. It does not invent product fields or report findings. Build scenario cards scenario_id : " SR-03" repository_type : " synthetic" seeded_conditions : - " one relevant issue" - " one plausible but irrelevant concern" - " one important omission" participant_goal : " ready, blocked, or escalate" success_evidence : - " decision cites inspected code" - " unsupported claim is challenged" - " unresolved uncertainty is recorded" stop_conditions : - " real credentials appear" - " a live repository could be modified" - " participant mistakes study output for production approval" Vary the seeded mix so participants cannot learn that every scenario contains exactly one true and one false finding. Establish ground truth independently before sessions. Recruit people who hold different review responsibilities: routine reviewers, maintainers, security specialists, less-experienced reviewers, and people using keyboard navigation or assistive technology. Do not collapse every group into one average. Require a decision record Decision: ready | blocked | escalate Evidence inspected: - file and relevant lines - test or documentation Guidance accepted: - claim and evidence Guidance rejected: - claim and reason Unresolved: - question and next owner Spoken confidence is not the outcome. This artifact exposes whether acceptance connects to evidence. Measure relevant issues identified, unsupported claims challenged, evidence references, correct escalation, time, and confidence before and after inspection. No