标签：#SEC

Two AI agents just fought over a Snowflake PR. You should read about it. In five days, two AI agents turned a Snowflake connector repo into a live demo of machine-vs-machine offense. On June 18, 2026, GitHub Copilot Autofix co-authored a commit that quietly dropped input sanitization from a shell-based run block. On June 23, an autonomous AI security agent — running an offensive scan — found the flaw, broke out of an echo string by crafting an issue title, and exfiltrated Jira credentials from Snowflake's GitHub Actions runner. No human analyst pulled the trigger. The patch landed within hours of detection, but the credentials were exposed in the gap. This is what an AI-on-AI supply chain fire looks like in 2026. It is also the most honest argument for treating AI-generated code the way we treat any other untrusted dependency: review it, sandbox it, and stop letting it author the parts that don't change. What Copilot Autofix actually changed The commit that broke the repo did not look alarming on the diff. Copilot Autofix — the automated remediation tool GitHub ships to close technical debt — proposed a refactor of a run block in a GitHub Actions workflow. The new version replaced the repo's existing sanitized input pattern with direct string expansion inside a shell script. Same behavior on the happy path. New script injection vector on every unhappy path. That is the threat model people don't draw in their head when they're using Copilot. The tool is optimizing for "looks right, runs right". It is not optimizing for "every quoted character is escaped in the shell interpolation that this string lands in". The minutes saved during authoring became the seconds the attacker needed to find the seam. [[COMPARE: the sanitized input pattern that was removed vs the direct string expansion that replaced it]] // The pattern that was removed // Before const safe = userInput . replace ( / [ ;&|`$<> ] /g , '' ); run : echo " $value " | process " $safe " // After — direct string

TL;DR: Most Laravel apps hit the same 5 authorization walls as they grow — role explosion, exception handling, multi-tenancy, contextual permissions, and debugging nightmares. This deep dive shows how to solve each one with modern patterns, and introduces a package that combines all solutions: Laravel Permission Manager . 🔗 GitHub · 📦 Packagist 📋 Table of Contents Introduction: The Authorization Ceiling Problem #1: The Role Explosion Trap Problem #2: The "Except This One" Problem Problem #3: The Multi-Tenant Nightmare Problem #4: The "Can They Edit THIS Post?" Problem Problem #5: The Silent Cache Bug Bonus: The 3 AM Debugging Nightmare The Complete Solution Real-World Implementation Comparison with Spatie Final Thoughts 🎯 Introduction: The Authorization Ceiling Every Laravel project starts with the same authorization story: // Day 1: Simple and beautiful if ( $user -> is_admin ) { // show admin stuff } By month three, it looks like this: // Month 3: Starting to hurt if ( $user -> hasRole ( 'admin' ) || ( $user -> hasRole ( 'editor' ) && $post -> status === 'draft' ) || ( $user -> hasRole ( 'manager' ) && $post -> department_id === $user -> department_id )) { // ... } By year one, you've got authorization logic scattered across controllers, policies, middleware, and blade templates — with no clear source of truth. This is what I call "The Authorization Ceiling" : the point where basic RBAC stops working and you need something more sophisticated. In this article, we'll explore the 5 most common authorization problems Laravel developers hit, why traditional solutions fail, and how modern patterns (and modern packages) solve them cleanly. 🔴 Problem #1: The Role Explosion Trap The Symptom Your application has roles: admin , editor , viewer . Life is good. Then the product team asks: "Can we have an admin who can't delete users?" "Can we have an editor who can publish but not delete?" "Can we have a viewer who can export reports?" Before you know it, you have 47 roles in

Multiple cybersecurity researchers said they suddenly lost access to OpenAI’s Trusted Access for Cyber (TAC) program, which offers models with fewer guardrails for vetted users.

The U.S. phone provider escaped a large-scale breach of its network after identifying Chinese-backed hackers early on.

With a looming IPO, intense competition from Anthropic, and Chinese and open-weight rivals nipping at its heels, OpenAI has plenty of reasons to move fast. Instead, it hit the brakes. On Tuesday, the company said it had slowed the pace of some AI development while it tightened security and safeguards. That included a two-week pause […]

WhatsApp is testing Scam Alert in limited beta, using on device machine learning to detect potential scam messages from non contacts. Meta's architecture keeps message content on the device while using confidential computing, Oblivious HTTP, differential privacy, and model transparency to measure performance and protect model delivery. By Leela Kumili

EVA Locker is a next-generation, client-side Zero-Knowledge cloud encryption platform designed to...

The cyberattack at CareCloud resulted in one of the largest reported data breaches in the U.S. healthcare industry this year.

Free model endpoints are seductive. Zero cost. Zero setup. Zero reason to trust them. I don't trust demos. I trust failure modes. So I built a small evaluation harness. It tests one thing: can a free model endpoint gate a pull request for secrets? This is not a benchmark. It's a repeatable experiment. You can run it in an afternoon. Disclosure: This article was prepared as part of MonkeyCode's product outreach. I used MonkeyCode's free model endpoint and the free server option for the test. No quotas. No hardware claims. Just a harness and a rubric. Why I stopped trusting free endpoints Free endpoints look great in a demo. You paste a diff. The model finds the secret. Everyone claps. Then you wire it into CI. The JSON breaks. The latency spikes. The model misses a private key. The demo didn't show that. An evaluation will. The experiment I designed a 40-minute test. It answers one question: where does the free endpoint perform well, and where does it break? The dataset is 30 synthetic diffs. Fifteen contain real-looking secrets. Fifteen are clean. Each diff is small. Each diff has one clear change. The prompt is strict. The model must return JSON. No prose. No apologies. Just a verdict. # eval_secret_gate.py # Simplified harness. Adapt to your client SDK. import json , time def classify ( client , diff : str ) -> dict : prompt = f """ You are a secret scanner for code review. Return ONLY JSON with this shape: {{ " contains_secret " : true, " line " : 12, " type " : " aws_access_key " }} Diff: { diff } """ start = time . time () response = client . complete ( prompt , model = " free " , server = " free " , # free server option ) latency = time . time () - start return { " latency " : latency , " raw " : response } def evaluate ( client , diffs , runs = 3 ): for i , diff in enumerate ( diffs ): for run in range ( runs ): yield i , run , classify ( client , diff ) The harness is deliberately small. It measures five things. Accuracy. JSON validity. Latency. Variance. Fa

ICE collected nearly a million DNA samples last year.

The people-search tool ClarityCheck says its reverse image search service is “private and secure”—but it left a database containing more than 9 million image files exposed.

AI coding agents are useful, but team collaboration around them can become messy very quickly. A common shortcut is to share an account, API key, or long-lived access token so another teammate can run a task. It may feel convenient, but it creates avoidable security, ownership, and review problems. A better approach is to separate the task from the account that executes it. The person requesting the work prepares a complete, portable task. The person running it uses their own authorized AI-agent subscription and returns the result with evidence. Here is a practical way to structure that workflow. Why shared AI accounts create problems When several people use the same AI account, it becomes difficult to answer basic operational questions: Who initiated a specific action? Which person approved the resulting changes? What project context was exposed? Who is responsible for reviewing the output? What happens when a teammate changes roles or leaves? Shared credentials also tend to spread. A password may end up in a private message, a token may be copied into a local configuration file, or a browser session may remain active on an unmanaged device. Even when everyone involved is trusted, the process itself is difficult to audit. The goal should not be to share access more efficiently. It should be to share the work without transferring the account. Treat the task as a portable unit A useful AI task should make sense outside the original conversation in which it was created. Someone receiving the task should be able to understand: the desired outcome; the relevant project context; the boundaries of the work; the evidence required for completion; the decisions that still need human review. This turns the request into a portable unit of work rather than a fragment of chat history. For example, instead of writing: Update the import flow. Write something closer to: When a user uploads a CSV containing duplicate email addresses, show a validation summary before importing any re

Flock’s surveillance cameras have already sparked outrage. WIRED reconstructed its next-generation AI system, already in use by some police, to confirm it goes much further than tracking license plates.

I work with PGP regularly and I work with it across multiple operating systems. Linux on my workstation, a MacBook on the go and every now and then I have to touch Windows. And on every single one of them, PGP means a different tool: Kleopatra on Linux, GPG Keychain on Mac, Gpg4win on Windows (which is Kleopatra again, just wrapped differently). Three tools, three UIs, three sets of quirks, three different workflows and none of them are what I'd call user-friendly. And yes, i know: the GnuPG CLI is the same everywhere, and it's a great tool. I use it. But gpg --encrypt --sign --armor -r test@key.com is not something I want to type 100 times a day and it's definitely not something I can give to a non-technical colleague. Every time I had to walk someone through encrypting or decrypting a message, I lost a bit of hope. So I made it my mission to finally build something better: PGP Manager . A free and open-source desktop app that looks and works the same on Linux, Mac and Windows. Why another PGP Tool? The cryptography behind OpenPGP is mature and has been trusted for decades. The problem was never the crypto, it's the workflow and the fragmentation. Encrypting a message for a colleague shouldn't require different tools per OS and a wiki page. My goal was simple: all the everyday PGP tasks in one place, without dumbing anything down or inventing a new format. PGP Manager is not a new crypto system. It uses gopenpgp v3 (ProtonMail's OpenPGP library) and standard OpenPGP (RFC 4880), so it stays fully compatible with GPG, Kleopatra, Thunderbird and the rest. You can leave anytime, your keys are just standard armored files. One more thing that sets it apart from the tools above: they're all frontends for a local GnuPG installation. PGP Manager brings its own OpenPGP implementation, so there's nothing else to install. It can still read an existing GnuPG keyring if you have one, but it doesn't need it. That's also what makes the standalone/USB mode possible in the first pla

For a healthtech verification link, the usual SendGrid vs Resend vs Postmark debate starts too late: the best alternative transactional email API is the one that leaves reviewable evidence after delivery. Short answer: choose a transactional email API only after a small evaluation proves API sending, controlled templates, verified-domain operation, suppression handling, and retrievable delivery records; Infrai is a practical option when those basics matter more than SMTP migration or webhook-driven automation, while teams that require either of those should keep a provider that supplies them. That result sounds less exciting than a feature matrix. Good. A verification message is part of an account-control path, so the useful output of a provider experiment isn't a polished welcome email. It's an evidence packet that connects one signup, one approved template revision, one domain configuration, one send request, and one later delivery record without placing health data in the message or logs. My first pass at this decision would be deliberately small: one synthetic recipient, one expiring link, one correlation ID, and no production data. I don't promote the notebook experiment until the evidence can be checked mechanically. The catch is that a provider can pass the send test while failing the operating model because an auditor cannot reconstruct what happened later. Reliability begins with five linked artifacts Start with five claims and demand an artifact for each. The API accepted a send. The rendered body came from the approved template revision. The sending domain was verified and DKIM could be rotated. A suppressed recipient wasn't treated as a normal send. Finally, a delivery record could be pulled into the team's own evidence store. Google also expects senders to authenticate mail, so domain work is part of the experiment rather than a launch-week chore. For a reviewer, those records need to form one understandable chain: the synthetic signup created a correla

🛡️ Arquitectura de Defensa para Agentes de IA: Cómo asegurar tus LLMs contra Prompt Injection, Tool-Poisoning y Fugitividad. El ecosistema actual de agentes autónomos y servidores MCP (Model Context Protocol) es brillante, pero operativamente es una pesadilla de seguridad. Estamos construyendo sistemas que ejecutan código, acceden a bases de datos y toman decisiones críticas basándose en salidas de texto que son intrínsecamente manipulables. Si estás desplegando agentes en producción confiando únicamente en que el modelo "se portará bien" gracias a su System Prompt, estás completamente desprotegido. Para solucionar esto, he desarrollado un framework de defensa en profundidad distribuido en 4 capas críticas. No se trata de teoría académica; son sensores deterministas y dinámicos listos para producción. 🏗️ Las 4 Capas del Ecosistema de Seguridad. Capa 1: Sanitización de Entrada y Control de Estímulos (Ingress). El ataque empieza antes de que el modelo procese el token. Necesitamos interceptar vectores maliciosos tanto en texto como en medios visuales. hermes-shield: Un sanitizador de entrada anti prompt-injection que opera en 5 capas secuenciales para neutralizar instrucciones hostiles ocultas. vision-injection-guard: Un sensor determinista diseñado para procesadores VLM. Detecta texto malicioso inyectado visualmente en imágenes antes de que el modelo de lenguaje lo interprete. corpus-scrub: Herramienta de prevención de fuga de datos. Detecta y redacta de forma automática PII (información personal identificable) y secretos en tus corpus de datos antes de entrenar o ajustar un LLM. Capa 2: Pasarela de Control y Validación Física (Gateway & Sandbox). Una vez que el agente está activo, no puede comunicarse directamente con el exterior sin un proxy que valide sus intenciones. ai-guard-gateway: Una pasarela de seguridad profesional para endpoints expuestos. Implementa Rate Limiting, redacción de PII en tiempo real, detección de inyecciones y políticas OPA (Open Policy Agen

Forminator Forms (CVE-2026-15748): Unauthenticated RCE via Forged Upload Settings in Select Fields 1. Basic Information Article Title : 600,000 WordPress Sites Affected by Arbitrary File Upload Vulnerability in Forminator Forms WordPress Plugin Publisher : Wordfence Intelligence Publication Date : 2026-08-17 Severity : High Original Source : Wordfence Related Sources : SecurityWeek Related Malware / Attack Groups : None / Unidentified CVE & Product : CVE-2026-15748, WordPress, Forminator Forms before 1.56.1 2. Summary An attacker can inject fake upload settings into a public form's Select field and bypass PHP blocks using strings like ph(p)|text/x-php . This uploads a file to the server. If the custom upload directory lacks execution prevention, it becomes an unauthenticated Remote Code Execution (RCE) vulnerability. 3. Attack Flow An attacker finds a public Forminator form that has both a File Upload field and a Select field. The attacker injects a fake record into the nested value of the Select field. This record includes return , field_type=upload , a custom name , and field_array . The function set_field_data() adds this fake record to the internal field_data_array . Because a real File Upload field exists, process_uploads() runs, and it trusts the fake record as a valid upload setting. The attacker controls the custom file type and additional-type . To bypass exact-match blocks for forbidden extensions, the attacker uses ph(p)|text/x-php . Because it is not an exact match for the key php , it passes the blocklist. However, the WordPress matcher matches ph(p) to .php . The server saves the PHP file. If the custom File Upload storage root lacks execution prevention (such as an .htaccess file), the attacker accesses the saved URL to run the PHP code. Inference : The attacker installs a web shell, steals WordPress settings, databases, or credentials, and defaces the site. 4. Attacker Position and Execution Location The attacker is external and can access public Wor

Clop's Windchill Web Shell: From Credential Decryption to Design Data Theft Inside the App 1. Basic Information Article Title : Clop Returns with Custom Implant in Mass-Extortion Campaign Publisher : ReliaQuest Threat Research Team Publication Date : 2026-08-18 Severity : Critical Original Source : ReliaQuest Related Sources : BleepingComputer , Ransom-ISAC Related Malware & Threat Groups : Clop / Cl0p, Windchill-specific JSP Web Shell CVE & Products : CVE-2026-12569, PTC Windchill, PTC FlexPLM 2. Summary This attack involves Clop exploiting a Windchill vulnerability to deploy a custom web shell. The web shell uses the application's own permissions and internal APIs to decrypt credentials in plain text, list design file locations, and steal the data. 3. Attack Flow Confirmed Core Chain Exploit CVE-2026-12569 on unpatched, internet-facing Windchill or FlexPLM servers. Place a custom JSP web shell inside the Windchill codebase. The attacker sends commands using the HTTP header X-windchill-req . The S command reads configuration files and uses WTKeyStoreUtil.decryptProperty() to decrypt saved secrets, such as LDAP administrator credentials. The L command queries Windchill database tables ( ApplicationData , FVITEM , FVMOUNT , MasteredOnReplicaItem , etc.) and writes file IDs, names, paths, and sizes to flst.txt . The G or D command reads the selected files. The server compresses the response with GZIP and returns it to exfiltrate the data. Optionally, the J command receives a Base64-encoded ZIP file to load and execute additional Java bytecode directly inside the Windchill process memory. Potential Subsequent Compromise Facts : The class loader can execute additional Java code in memory. Inference : Decrypted LDAP or admin credentials can be used to authenticate to other systems and move laterally. Hypothesis : Attackers may deploy ransomware or long-term persistence modules against organizations that refuse to pay. 4. Attacker Position and Execution Location The initi

Building Secure AI-Powered Applications with Laravel, APIs and Modern Agentic Architectures Introduction AI-powered applications are moving beyond simple chat interfaces. Modern AI systems can interact with APIs, databases, external services, and business workflows, allowing AI agents to perform actions rather than simply generate responses. This creates a new security challenge. A traditional API may follow: User → API → Database → Response An AI-powered application can look more like: User ↓ AI Agent ↓ Tool / API ↓ Business Logic ↓ Database / External Service ↓ Action The difference is important because an AI agent may make multiple decisions and tool calls during a single workflow. OWASP’s current GenAI security guidance identifies risks including prompt injection, sensitive information disclosure, improper output handling, excessive agency, and unbounded consumption. (OWASP Foundation) Therefore, securing an AI API requires more than protecting an API key. Developers need layered controls for authentication, authorization, rate limiting, input validation, tool permissions, data protection, human approval, and monitoring. 1. Why AI APIs Are Different Traditional APIs usually perform clearly defined operations: POST /api/orders The application can authenticate the user, validate the request, check authorization, and process the order. An AI agent introduces another layer: User Request ↓ AI Agent ↓ Select Tool ↓ API Request ↓ Authorization ↓ Business Logic ↓ Action For example, a customer might ask: “Check my latest order and process a refund if I am eligible.” The agent could potentially: Find the customer. Retrieve the order. Check the refund policy. Call a payment API. Create a refund. Notify the customer. Each operation represents a potential security boundary. This is why agentic systems require controls over not only individual API calls, but also the actions an agent is allowed to perform. OWASP specifically identifies excessive functionality, excessive perm

The hard part of a fast-moving plugin ecosystem is rarely finding another project. It is deciding whether a project deserves a place in a working setup. DeepSeek Harness is a developer preview with a plugin-first architecture, and its surrounding ecosystem already includes interface extensions, vision tools, workflow helpers, terminal experiences, and desktop clients. Those projects can be useful, but an install command is not a review process. A plugin may execute with local permissions and interact with files, credentials, networks, or shell commands. That is why I prefer repository-first discovery. DSH Hub is a bilingual directory for DeepSeek Harness plugins and clients. Its rule is simple: every listed item must point to a publicly reachable GitHub repository. The goal is not to turn a catalog into a trust badge. The goal is to make the source, ownership, license, release history, and installation material easy to inspect before an extension enters a Harness profile. What the directory separates DSH Hub keeps clients and plugins in different groups. A plugin usually adds a narrow capability to a running Harness profile. A client can do more: package a runtime, provide its own update path, expose a network listener, or ship a bundle of extensions. That difference changes what needs review. If both are listed as the same kind of tool, it is easy to miss the extra surfaces a client can introduce. The August 18, 2026 catalog snapshot contains 19 plugins and 6 clients. Discovery starts with the official DeepSeek Harness repository, the GitHub dsh-plugin topic, and a community-maintained registry. Each selected repository is then checked for a clear, public connection to the ecosystem. A practical evaluation loop A short loop catches more than a long list of popularity signals: Run the official Harness first, so you understand the baseline behavior. Choose the single capability you actually need instead of adding a large bundle. Open the linked repository. Read its R