Post Syndicated from BeardedTinker original https://www.youtube.com/watch?v=9neVHbROeaw
Is It Time to Kill the Filibuster? | The David Frum Show
Post Syndicated from The Atlantic original https://www.youtube.com/watch?v=96jQfF9mMEE
I Told My Crew to Pick ANY Camera Gear They Wanted…
Post Syndicated from Matt Granger original https://www.youtube.com/watch?v=A4_dDFC7wQs
The new bigger better Petru Sync Pro
Post Syndicated from Techmoan original https://www.youtube.com/watch?v=_l5OPmybLsI
Седмицата (16–21 ноември)
Post Syndicated from Йовко Ламбрев original https://www.toest.bg/sedmitsata-16-21-noemvri/

Къса клечка изтеглиха Румен Радев и последователите му от „Прогресивна България“ с този прекалено щедър на доверие електорат. Вместо да спечелят малко по-умерено и да си скалъпят някоя удобна „сглобчица“ – в която партньорите им хем да са перманентно виновни за всичко, хем да служат за удобно извинение за по-трудните решения, докато държавицата ни криво-ляво крета по правия път, – сега им се налага да я управляват самостоятелно, че и да носят отговорност за това. Пък така да им личи, че не я умеят тази работа.
Толкова не я умеят, че едва не загубиха президентските избори, бюджет 2027 продължава да скърца по пътя си през парламента, а още преди серията инциденти в Черно море най-висшият военен в страната – началникът на отбраната адмирал Емил Ефтимов – подаде рапорт за напускане. Президентката Илияна Йотова е подписала указ за освобождаването му миналия петък, 13 ноември.
Само един уикенд по-късно, в понеделник, беше обявено, че се оттегля и нейният съветник по националната сигурност вицеадмирал Митко Петев. Официалното обяснение и за двамата е пенсиониране – и въпреки спекулациите, че Петев ще бъде предложен за мястото на адмирал Ефтимов, от последните новини научаваме, че той е отклонил предложението.
С лични мотиви, които „не се коментират“, напусна в началото на ноември и председателят на „Прогресивна България“ в Пловдив Ангел Стоев – неколкократен областен управител на Пловдив по време на служебните кабинети на Радев.
Рано е да се говори за разпад отвътре, но… тези събития са любопитни и заслужават внимание. Още повече когато кораби продължават да потъват около нашите брегове, а премиерът генерал дискутира с опозицията формата на Земята…
За ужас на „Прогресивна България“ от тази седмица в „Тоест“ се завръща и рубриката ни за политическа сатира „Т.Е. от Е.Т.“ със специален епизод, посветен именно на прогресистите.
„Т.Е. от Е.Т.“ се завърна, но Илияна Йотова – не. Спечели изборите и потъна в мълчание. Липсват коментари от страна на президентката за последните атаки по кораби в Черно море; не излезе с изявление, за да изкаже съболезнования за близките на жертвите от тежката катастрофа на магистрала „Тракия“; съветникът ѝ по сигурността напуска – тишина; мълчи за споровете около държавния бюджет; отсъства от срещи и регионални инициативи за отбрана… Но така е – когато избираме президент аватар, получаваме аватар на президент.
В седмичния си политически коментар „Йотова, Йотова, обади се!“ Емилия Милчева анализира поведението на държавния глава Илияна Йотова след спечелването на балотажа и заключава, че вместо да изпълни предизборните си обещания да бъде „коректив“ на институциите, тя е избрала ролята на мълчалив статист на премиера Румен Радев.
И още нещо много важно. Според вас колко често е приемливо името на ръководителя на държавна информационна агенция да присъства в собствения ѝ новинарски поток? В анализа „Кирил Вълчев, или когато новинарят стане новината“ автор, чиято анонимност искаме да опазим чрез псевдонима Евгени Соколов, проследява над 4000 публикации на Българската телеграфна агенция, в които се споменава нейният генерален директор и наскоро новоизбран вицепрезидент Кирил Вълчев.
Според изчисленията в текста, базирани на архив от проверими заглавия и дати, от встъпването му в длъжност през януари 2021 г. до включването му в президентската надпревара през септември 2026 г. името на Вълчев се появява средно по 2,2 пъти на ден, без той да е автор на нито един материал. Става още по-лошо, когато същите публикации се разпределят в десет категории и се окаже, че с най-голям дял – 31,4% – са текстове за събития без видима връзка с управлението на Агенцията.
Следва най-логичният въпрос: използвана ли е БТА като инструмент за личен пиар и защо полирането на обществения имидж на Кирил Вълчев трябва да се финансира от данъците на всички българи?
След разследването на Венелина Попова за командировките на директора на БТА в „За истината“ и публикацията на анализа на Евгени Соколов в „Тоест“, които бяха цитирани и от много други медии, Кирил Вълчев все пак подаде оставка като ръководител на БТА.
Важно! Изтичат последните дни на краудфъндинг кампанията за следващия ни документален филм „Какво е да си млад в България“. Още сме далеч от събирането на нужната сума и ще трябва да потърсим друго финансиране, за да осъществим този проект, но можете да помогнете да покрием поне втория му етап. Всяко евро има значение. Включете се! Припомнете си и предишния ни филм „Какво е да остарееш в България“.
Във втория текст от поредицата си „Анатомия на пола: Менопауза“, озаглавен „Холи Бери е в менопауза. И сега какво?“, Надежда Цекулова проследява как темата за преходната възраст, едва излязла от зоната на здрача, завива рязко по пътя към доходоносните индустрии, преди да се превърне в реална обществена политика. Давайки примери с лъкатушенията на холивудската актриса по темата – от застъпничеството ѝ за реформа в медицинското образование до собствената ѝ комерсиална платформа, – Надежда разказва и за българския бум от инициативи, в които границата между полезната информация и агресивния маркетинг става все по-трудно различима.
На фона на факта, че едва 6,8% от специализиращите лекари се чувстват подготвени по темата, превръщането ѝ в пазарна ниша лишава жените от достъпна и научно обоснована медицина. А те вместо от скъп „ребрандинг“ на възрастта си имат нужда от компетентни лекари и от възможност да остаряват без допълнителни тревоги.
Каква е истинската цена на оцеляването, когато то те осъди да помниш завинаги, а обществото те превърне в кух паметник на героизма? Гостуването на австралийския писател Ричард Фланаган у нас провокира Антония Апостолова да се върне към неговия епос „Тесният път към далечния север“, награден с „Букър“. Насред кал, болести и нечовешка жестокост, оцеляването в тази книга не е възвишена саможертва, а груб „просветен егоизъм“ и прагматична солидарност, които превръщат оцелелите в емоционално вцепенени носители на доживотна травма.
Антония Апостолова обаче прочита тази класика и през неудобните въпроси на днешния ден, например: можем ли да си позволим лукса на релативизма и фразата „въпрос на гледна точка е“ във време, когато политиците се страхуват недвусмислено да назоват агресора в съвременна война? Не пропускайте този проницателен анализ за един брутален и лиричен роман, който разказва за смъртта на духа след оцеляването на плътта.
Какво е общото между данъчна измама за 7 млн. лева с подставено лице и кражба на телефон и 30 лева в столичния квартал „Надежда“? Във втората част на поредицата си „Професия: Съдебен заседател“ Стефан Иванов описва дебюта си в съдебната зала, където абстрактните параграфи на закона се сблъскват с човешката крехкост. Пред стерилния юридически катехизис двата случая имат еднаква процесуална тежест, но отвъд ритуала прозира сериозен системен дефицит: съдът отнема конфликта от хората и го превръща в суха административна процедура, вместо да търси пътища за реално поправяне на вредата чрез практиките на възстановителното правосъдие.
Стефан Иванов посочва и един тревожен структурен дефект – институцията на съдебните заседатели, замислена като глас на гражданското общество и здравия разум, у нас често се запълва от бивши кадри на МВР и на съдебната система, превръщайки се в ехо на самата власт. Прочетете този лишен от всякаква патетика разказ отвътре за съдебната машина, в който най-ясният урок за цената на свободата се научава не в залата, а в момента, в който излезеш на чист въздух през вратата на съда.
В статията си „Студио „Комплект“: Дизайнът е човешка дисциплина“ Ина Иванова ни среща с Адриана Андреева и Бояна Гяурова, създателките на една от първите агенции за културен мениджмънт у нас и организаторки на фестивала „Мелба“. Интервюто изважда дизайна от неговия бутиков балон, за да го покаже като форма на вдъхновение, която има силата да решава социални и екологични проблеми, но и като невидимата логика зад всеки предмет около нас.
Този разговор ни напомня също, че вкус и среда се възпитават – чрез обща култура, четене и мислене, без които обществото лесно се превръща в жертва на манипулации.
И преди да се разделим тази седмица… Нека отново напомним, че качествената журналистика няма как да е безплатна. Ако не осъзнаем, че трябва и е важно да я подкрепяме, някой друг ще плаща за това, което според него трябва да четем (и да мислим). Демокрацията ни зависи от наличието на свободни и критични към властта медии.
Ако материалите на „Тоест“ ви харесват и искате да продължим, подкрепяйте ни ежемесечно със сума според възможностите си.
Приятно четене!
Welcome to Software Beirut
Post Syndicated from The Atlantic original https://www.youtube.com/shorts/izXL0JnPfq0
JEDEC Previews DDR6 Memory Standard: 2.35x More Bandwidth, 44% Narrower DIMMs
Post Syndicated from Ryan Smith original https://www.servethehome.com/jedec-previews-ddr6-memory-standard-2-35x-more-bandwidth-44-narrower-dimms/
JEDEC has unveiled the first specifications for DDR6 memory. Targeting over twice the bandwidth of DDR5, and with DIMMs 44% smaller, DDR6 is slated to be the biggest change in generations to the server memory standard
The post JEDEC Previews DDR6 Memory Standard: 2.35x More Bandwidth, 44% Narrower DIMMs appeared first on ServeTheHome.
Scope down permissions of existing sessions using AWS STS GetScopedCredentials
Post Syndicated from Vaishnavi Merugu original https://aws.amazon.com/blogs/security/scope-down-permissions-of-existing-sessions-using-aws-sts-getscopedcredentials/
When you build AI agents, you often want each agent or sub-agent to have only the permissions its tasks require, rather than the full permissions of the session that started it. GetScopedCredentials is a new AWS Security Token Service (AWS STS) API that you can use to scope down the permissions of existing temporary security credentials. You can assign each agent, sub-agent, or process its own set of credentials that keep the caller’s AWS Identity and Access Management (IAM) identity but carry reduced permissions, a shorter session duration, or both.
You can call GetScopedCredentials with the temporary security credentials you already use, such as those from aws login, an Amazon Elastic Compute Cloud (Amazon EC2) instance profile, or an AWS Lambda function. In each call, you pass a scope down policy, a shorter session duration, or both. A scope down policy is an inline policy that describes the maximum permissions for the new credentials. The resulting permissions are the intersection of your session’s effective permissions and the scope down policy, so they can only be reduced. Similarly, the session duration you request can’t exceed the remaining duration of the calling session. You can also call GetScopedCredentials again with the resulting credentials to scope down permissions or reduce session duration even further.
GetScopedCredentials is designed as a building block. Because it scopes down permissions on the credentials you already have, you can build it into agent frameworks, services that issue credentials to other components, continuous integration and deployment (CI/CD) pipelines, and your own applications. You can also call it again with scoped-down credentials, so an orchestrating agent can give each sub-agent narrower access than its own.
In this post, we walk through a few common use cases to get you started, show you how to call GetScopedCredentials, and explain how to manage access to it.
Example use cases
You can use GetScopedCredentials whenever a workload needs narrower access than the session that starts it. Examples include limiting what AI agents can do, scoping down permissions based on runtime context, and granting just-in-time access. We cover two of the most common use cases in more detail in this section.
Limit what AI agents can do
When you pass credentials to an agent, the agent can use any permission those credentials carry. An agent decides which actions to take at runtime, often based on prompts or tool output. If its credentials are overly permissive, an agent that makes a mistake can act beyond the task you gave it.
Before you pass credentials to an agent, you can use GetScopedCredentials to scope down permissions to only what its tasks require, such as read access to a single Amazon Simple Storage Service (Amazon S3) bucket. You could also take the opposite approach and keep most of its permissions while removing only the actions the agent should never perform, such as deleting resources. An orchestrating agent can do the same for each sub-agent it starts. Because a scope down operation can only narrow permissions, a sub-agent never has more access than the agent that started it. To help ensure that your agents only have access to the scoped-down credentials, run them in isolated or sandbox environments such as AWS Strands Box.
Scope down permissions based on runtime context
Many workloads run under a single IAM role but need different, narrower permissions for each task they perform. The right set of permissions for a task often depends on information the workload learns only at runtime, such as who sent a request.
Consider a multi-tenant application that stores each tenant’s files under a separate prefix in one S3 bucket. This application uses a single IAM role to serve all its tenants, so the role can access every tenant’s prefix. However, each request should reach only the files of the tenant who sent it, and the application learns which tenant that is only after it authenticates the request. At that point, a trusted credential broker in the application takes the tenant details from the authenticated session and calls GetScopedCredentials with a scope down policy that allows access only to that tenant’s prefix. It passes only the scoped-down credentials to the worker that handles the request, so Amazon S3 denies that worker access to other tenants’ prefixes even though the original role covers them all.
How to call GetScopedCredentials
This section walks through the process of scoping down permissions for an existing session. Before you call GetScopedCredentials, make sure you have valid temporary security credentials and that they have the permissions to call the API. The following identity based policy grants that permission.
To call GetScopedCredentials, use the latest version of the AWS Command Line Interface (AWS CLI) or the AWS SDK for your programming language.
Step 1: Define a scope down policy
Write a scope down policy that describes the maximum permissions the resulting credentials should have. At launch, GetScopedCredentials accepts one inline scope down policy of up to 2,048 characters. You can write a scope down policy in many ways, such as authoring a policy from scratch, reusing or modifying an existing policy, or asking an AI assistant to draft one. This section covers two such approaches.
Option A: Write the policy yourself
If you know which actions and resources your task needs, write the policy directly. The following sample policy allows the resulting credentials to only read objects from a single S3 bucket.
Make sure to include every action the task needs, including dependent actions. For example, if your task uses Amazon Athena to query data in Amazon S3, the policy must also allow s3:GetObject on that data, because Athena reads it with your credentials.
To keep most of the calling session’s permissions and remove only a few sensitive ones, use an Allow statement with NotAction. This statement doesn’t grant additional access, because a scope down policy can only reduce permissions. The resulting credentials keep the calling session’s permissions except the actions you list, which makes this a quick way to set guardrails without listing each action a task needs. The following sample policy blocks identity and account management, assuming other roles, and deleting some critical resources.
Option B: Generate the policy with IAM Policy Autopilot
You can also use IAM Policy Autopilot to generate a scope down policy. IAM Policy Autopilot is an open source tool from AWS that analyzes the AWS SDK calls in your code and identifies the permissions it requires to run successfully. You can run it from the command line or as a Model Context Protocol (MCP) server in your AI coding assistant. To install it, see the Getting Started instructions for IAM Policy Autopilot.
We’ll use the following Python code to generate a scope down policy using IAM Policy Autopilot. It records a report’s status in an Amazon DynamoDB table.
Save the code as report_status.py and run the following command. If the generated policy exceeds the 2,048 character limit, set the max-policy-size and allow-overpermissive-wildcards-to-limit-total-output-size options to 2048. IAM Policy Autopilot then replaces groups of actions with wildcards to fit that size and warns you if it can’t.
IAM Policy Autopilot returns the following policy.
IAM Policy Autopilot generates a starting policy that can include wildcards, either because specific resources can’t be inferred from the code, such as with the table/* and key/* resources in this example, or because an optional parameter that limits policy size replaced actions with wildcards. Review the generated policies and replace the wildcards with the actions and resources your task should access.
However you create the policy, save it as scope-down-policy.json. If you want to continue calling GetScopedCredentials with the resulting credentials, also include the sts:GetScopedCredentials action in the Allow block of the permission policy.
Step 2: Call GetScopedCredentials
Pass the scope down policy you created to GetScopedCredentials. The following command also uses the optional duration-seconds parameter to limit the resulting session duration and the optional scoped-session-description parameter to record context for the scoped-down credentials. If you omit the duration-seconds parameter, the credentials keep the calling session’s remaining duration.
The response includes a new set of temporary security credentials, a SessionInfo element, and some helpful information about session size and contents.
Notice that the Amazon Resource Name (ARN) in the SessionInfo element matches the ARN of your calling session. The scoped-down credentials retain the identity of the calling session, including the role session name, session tags and context keys.
The ScopedPoliciesCount value in the response shows how many scope down policies apply to the session. It increases only when a recursive call adds a new scope down policy and not when a call only shortens the session duration.
Each GetScopedCredentials call is logged in AWS CloudTrail. The following event, shortened for readability, shows the call from this example.
The scopedSessionDescription value in the CloudTrail event records the text you passed to the API call earlier. Later calls made with the scoped-down credentials show the scoped down session’s access key ID in userIdentity.accessKeyId, which can be used to trace back to its immediate parent session.
Step 3 (optional): Scope down the credentials again
You can call GetScopedCredentials recursively with the scoped-down credentials to narrow permissions or reduce session duration even further. You can apply a maximum of three scope down policies to a session, and each new scope down policy intersects with all prior ones. Recursive calls that only shorten the session duration and don’t add a scope down policy don’t count toward this limit. For a recursive call to succeed, every earlier scope down policy must allow the sts:GetScopedCredentials action.
Managing access to GetScopedCredentials
You can control access to the sts:GetScopedCredentials action in all relevant policy types. You can also use the sts:DurationSeconds condition key to limit the session duration of scoped-down credentials, and global condition keys such as aws:PrincipalArn, aws:PrincipalTag, and aws:SourceVpce to restrict who can call the API and from where.
Availability and request quota
GetScopedCredentials is available in all AWS commercial Regions, AWS GovCloud (US) Regions, and the China Regions. The API has a dedicated request quota of 200 requests per second per account in each Region at launch. You can use scoped-down credentials with most AWS services. For a list of services that aren’t supported, see the GetScopedCredentials API reference.
Conclusion
GetScopedCredentials gives you a building block for reducing permissions at runtime. This is particularly helpful when you want to give each agent, sub agent or workload only the access it needs.
For more information about GetScopedCredentials, see the GetScopedCredentials API reference. To learn how permissions are evaluated for scoped-down credentials, see Permissions for GetScopedCredentials and Policy evaluation for requests within a single account. Now go build!
If you have feedback about this post, submit comments in the Comments section below. If you have questions about this post, start a new thread on AWS re:Post or contact AWS Support.
Friday Squid Blogging: The Largest Squid Ever Filmed
Post Syndicated from Bruce Schneier original https://www.schneier.com/blog/archives/2026/11/friday-squid-blogging-the-largest-squid-ever-filmed.html
This is the story of the largest squid ever filmed, in December 2006 near Japan’s Ogasawara Islands.
As usual, you can also use this squid post to talk about the security stories in the news that I haven’t covered.
How Cloudflare WAF protects against ruby2shell (CVE-2026-132825)
Post Syndicated from Daniele Molteni original https://blog.cloudflare.com/ruby2shell-waf-protection/
On November 19, 2026, the Ruby team disclosed ruby2shell (CVE-2026-132825), a heap buffer overflow in the way Ruby changes the case of strings. Ruby rates the flaw Critical and says it is aware of proofs of concept that achieve remote code execution in some scenarios. Fixes shipped in Ruby 3.3.14, 3.4.13, and 4.0.10.
The reach is wide. Veria Labs reports that Ruby on Rails and classic-style Sinatra applications reach the bug in their default configuration, before any authentication. Self-hosted products that bundle Ruby, including GitLab, GitHub Enterprise Server, Mastodon, OpenProject, Discourse and Chatwoot, shipped an affected Ruby in their latest release at the time of disclosure.
Cloudflare WAF blocks ruby2shell for all customers, including those on the Free plan. We have added two rules to both the Cloudflare Free Managed Ruleset and the Cloudflare Managed Ruleset, with Block as the default action: one for ruby2shell and one for GHSA-87fm-7w84-j2px, a related integer overflow in Ruby string case conversion fixed in the same releases.
The WAF is a compensating control, not a replacement for patching. Exploits can reach the bug through paths a WAF does not see, and the only complete fix is to upgrade Ruby. Our team continues to monitor attack traffic and will update the rules as new techniques appear. You can track rule changes in the WAF changelog and get the latest on the vulnerability in the Cloudflare Zero Wire briefing.
Cloudflare has patched its own systems that use Ruby, and we have found no indication of compromise.
What we know about ruby2shell
Ruby strings carry an encoding, and Ruby still supports many legacy single-byte encodings, such as ISO-8859-1 (Latin-1) and Windows-1252, alongside UTF-8. In a single-byte encoding each character takes one byte, so changing the case of a string usually produces output of the same length.
The German sharp s (ß) breaks that assumption. Its uppercase form is two characters, SS. In 14 ISO-8859 and Windows-125x encodings, Ruby writes those two bytes but checks for room for only one. According to Veria Labs, a string with 21 sharp s characters overflows the output buffer by one byte. The methods that reach the bug are upcase, swapcase, downcase(:fold) and casecmp?. UTF-8 strings take a different code path and are not affected.
A one-byte overflow can look harmless. In a memory-corruption exploit, though, a single byte written past the end of a heap buffer can be enough to corrupt an adjacent object or allocator metadata. Ruby says it is aware of proofs of concept that turn this flaw into code execution, and Veria Labs says it will publish its own proof of concept about a week after disclosure. We expect scanning to start soon after.
Why default Rails and Sinatra apps are exposed
HTML forms can only send GET and POST requests. To simulate PUT, PATCH, or DELETE, many web frameworks accept a _method parameter in a POST request. Rack, the interface most Ruby web frameworks build on, implements this in its MethodOverride middleware, which converts the value of _method to uppercase. Rails includes this middleware by default, and classic-style Sinatra applications enable it. An attacker can send a multipart POST request whose _method part declares a legacy character set and contains a run of sharp s characters. The framework upcases the value while it is still routing the request, before any application code or authentication check runs.
Veria Labs reports that other frameworks and plain Rack applications are not exposed by default. Application code that changes the case of strings received in a legacy encoding may still be affected, wherever the string comes from.
Who is affected
|
Condition |
Details |
|
Ruby version |
Ruby 3.3.13 and earlier, 3.4.0 through 3.4.12, and 4.0.0 through 4.0.9. Veria Labs reports the bug has been present since Ruby 2.4.0. Ruby 3.2 and earlier have reached end of life and will not receive the fix. |
|
Framework |
Rails and classic-style Sinatra in their default configuration. Any other code that changes the case of attacker-controlled strings in a legacy single-byte encoding. |
|
Bundled software |
As of November 19, 2026, Veria Labs lists GitLab 19.6.0, GitHub Enterprise Server 3.22.5, Mastodon 4.7.5, OpenProject 17.9.7, Discourse 2026.10.1 and Chatwoot 4.20.0 as bundling an affected Ruby in their latest release. Discourse moved its Docker base image to Ruby 4.0.10 on November 19, so rebuilding a Docker install picks up the fix. |
Distribution packages can backport fixes without changing the Ruby version number, so check the full package version against your distribution's advisory.
Six more Ruby flaws in the same release
Ruby 3.3.14, 3.4.13, and 4.0.10 also fix six other memory safety flaws, and Ruby says several of them can lead to code execution. One, GHSA-87fm-7w84-j2px, is an integer overflow in the same string case conversion code, and our second WAF rule covers it. The other five are in Ruby's regular expression engine. Most of them require the application to compile or match a regular expression pattern supplied by the attacker. That is uncommon in web applications, but it does happen in search features, filtering rules and admin tools.
How Cloudflare WAF protects you
Upgrading every Ruby runtime takes time, especially when Ruby is bundled inside self-hosted products and container images. Cloudflare WAF reduces your exposure while you patch.
New managed rules, on for every customer
Both rules are part of the Cloudflare Free Managed Ruleset and the Cloudflare Managed Ruleset (Ruleset ID efb7b8c949ac4650a09736fc376e9aee), with Block as the default action.
|
Rule description |
Rule ID |
Ruleset |
Default action |
|
Ruby – Heap Overflow – CVE:CVE-2026-132825 |
7328f23691e44b07892ebd25b19210f1 |
Cloudflare Free Managed Ruleset (Free plan) |
Block |
|
Ruby – Heap Overflow – CVE:CVE-2026-132825 |
1afa543a1ed84893b01df04c34402c88 |
Cloudflare Managed Ruleset (Pro, Business and Enterprise plans) |
Block |
|
Ruby – Integer Overflow – GHSA-87fm-7w84-j2px |
8660e37e86444f9f9267ba22e9855f05 |
Cloudflare Free Managed Ruleset (Free plan) |
Block |
|
Ruby – Integer Overflow – GHSA-87fm-7w84-j2px |
6defac6a52334542adf4a162daf25922 |
Cloudflare Managed Ruleset (Pro, Business and Enterprise plans) |
Block |
On the Free plan, the Cloudflare Free Managed Ruleset runs automatically, so there is nothing to turn on. On paid plans, the rules are active wherever the Cloudflare Managed Ruleset is deployed. Because paid plans give you more control over how rulesets are deployed, the Cloudflare Managed Ruleset may not be active on every zone. We recommend checking its status to confirm that it is running. You can use the links in the Zero Wire briefing to go straight to the rules in your dashboard.
What the WAF cannot see
A WAF can block an exploit when the malicious input arrives in an HTTP request that passes through Cloudflare. It cannot block every path to the vulnerable code:
- Traffic that bypasses Cloudflare. Requests sent directly to your origin IP address, and traffic between internal services, never reach the WAF. Configure your origin to accept traffic only from Cloudflare, for example with Cloudflare Tunnel or Authenticated Origin Pulls.
- Other entry points into the same code. Ruby code that changes the case of strings from email, file imports, message queues or background jobs can reach ruby2shell without an HTTP request.
Adding defense in depth with WAF attack score
Memory corruption is usually only the first step. To run commands, an attacker still has to deliver a second-stage payload, such as shell commands or a reverse shell, and then interact with the compromised server. WAF attack score uses machine learning to score each request for remote code execution payloads, which helps catch exploit variations and post-exploitation traffic that signature-based rules can miss. Create a custom rule that blocks or challenges requests with cf.waf.score.rce le 20 on Enterprise plans, or cf.waf.score.class eq "attack" on Business plans.
Impact on Cloudflare infrastructure
Cloudflare has patched its systems that use Ruby against ruby2shell. We have found no indication of compromise and continue to monitor.
Patch now
ruby2shell turns a one-byte miscalculation in string case conversion into a pre-authentication path to code execution in default Rails and Sinatra apps. With a public proof of concept expected within days, the window to patch is short. Here is what to do:
- Check your WAF coverage. On the Free plan, the ruby2shell rules are already blocking. On paid plans, confirm the Cloudflare Managed Ruleset is deployed and the rules have not been overridden.
- Upgrade Ruby to 3.3.14, 3.4.13 or 4.0.10 and restart every Ruby process, including background workers. Rebuild container images. Move applications on Ruby 3.2 or earlier to a supported series.
- Update self-hosted products that bundle Ruby, such as GitLab, GitHub Enterprise Server, Mastodon, OpenProject and Chatwoot, as each vendor releases a fix. Rebuild Discourse Docker installs now.
- Inventory your runtimes. The Zero Wire briefing includes a prompt you can give an AI agent to find every affected Ruby runtime in your infrastructure.
Our WAF analysts will keep updating protections as new techniques appear. Follow the WAF changelog for rule updates.
How Cloudflare WAF helps protect against phpAfterShell and other critical PHP flaws
Post Syndicated from Daniele Molteni original https://blog.cloudflare.com/phpaftershell-waf-protection/
On November 19, 2026, the security research company depthfirst disclosed phpAfterShell (CVE-2026-126714), a vulnerability in PHP's default file-based session handler that can lead to remote code execution. Under the Common Vulnerability Scoring System (CVSS) 4.0, it scores 9.2 out of 10 (Critical). The PHP project fixed it the same day in versions 8.2.36, 8.3.37, 8.4.28, 8.5.13, and 8.6.0. These releases fix 16 other security vulnerabilities, six of them also rated critical.
Cloudflare’s web application firewall (WAF) blocks known phpAfterShell attack patterns, including for customers on the Free plan. The protection comes from a PHP remote code execution rule we first deployed in October 2026 for the php2shell vulnerabilities. That rule already detected part of the phpAfterShell attack pattern before the vulnerability was disclosed, and on November 19 we updated its detection logic to cover phpAfterShell. The rule is part of both the Cloudflare Free Managed Ruleset and the Cloudflare Managed Ruleset, is enabled by default, and its default action is Block.
In the same WAF release, we added three new rules to the Cloudflare Managed Ruleset for paid plans: one for a request smuggling flaw in PHP-FPM (CVE-2026-129289), and two for flaws in PHP's SOAP extension (CVE-2026-15353 and CVE-2026-129506) that PHP fixed in the same releases. These rules are enabled by default with the Log action, because the request patterns they look for can also appear in legitimate traffic, and blocking by default could disrupt it. Customers can review matching requests in Security Events now and change the action to Block once they confirm the rules do not affect legitimate traffic.
The WAF is an additional layer of defense, not a replacement for the patch. Several of the critical flaws depend on server configuration or can be reached through paths a WAF does not see, and the only complete fix is to upgrade PHP and restart every worker. Our analysts continue to monitor attack activity and will update the rules as new techniques and variations appear. You can track rule changes in the WAF changelog and follow how the vulnerabilities develop in the dedicated Cloudflare Zero Wire briefing.
There appears to be no indication so far that these vulnerabilities have been exploited. As of November 19, 2026, none of the 17 vulnerabilities was listed in CISA's Known Exploited Vulnerabilities catalog, and no source we reviewed reports exploitation in the wild.
What we know about phpAfterShell
PHP stores session data in files by default. When an application calls session_start(), PHP reads the session file and deserializes its content into the $_SESSION array. When the request ends, PHP writes the updated session back to the same file.
phpAfterShell is triggered when that write is interrupted. The session file can then hold the beginning of the new session data followed by the end of the old one. On the next request, session_start() deserializes this mixed content. If an attacker controlled the old data, PHP can end up deserializing objects of the attacker's choice.
An attacker trying to exploit the flaw is likely to first search for a way to place controlled data in the session. PHP's advisory names two:
- Session upload progress, a PHP feature that writes information about a running file upload into the session. A remote client can use it to shape the stored data.
- Applications that store large user-controlled strings in the session.
According to PHP, code execution also requires an interruption at a useful point in the write and a suitable deserialization gadget chain in the application. depthfirst reports that it reached code execution without an application gadget by chaining a second, undisclosed memory-corruption bug in a PHP-native class. The sources we reviewed do not establish whether that second bug is fixed in the November 19 releases.
depthfirst says it discovered and reported phpAfterShell. The CVE record credits Leo Lin and Asahi as reporters.
The other critical flaws
The same releases fix six more critical vulnerabilities. Each one needs a specific configuration to be exploitable:
|
CVE |
Component |
Impact |
Conditions |
|
CVE-2026-129289 |
PHP-FPM |
An unauthenticated attacker can smuggle a second FastCGI request into PHP-FPM and run PHP code as the worker. |
A front end that reuses backend FastCGI connections (nginx with fastcgi_keep_conn on, Apache mod_proxy_fcgi with enablereuse=on, or HAProxy), an application path that opens php://input without reading it to the end, and the path of an existing PHP script. |
|
CVE-2026-115560 |
Session serializer |
Object injection through a mismatch between session serializers. First covered in our php2shell briefing, now fixed. |
Session upload progress enabled. PHP widened the scope: applications, pools or command-line jobs that use different serializers and share a session store are affected. |
|
CVE-2026-129496 |
Timezone cache |
Use-after-free that can crash a fresh worker and possibly run code. PHP demonstrated code execution locally with known memory addresses. |
Non-thread-safe builds where a startup diagnostic has been written to a PHP error log file. |
|
CVE-2026-129481 |
Session shutdown |
Use-after-free, described by PHP as an incomplete fix for CVE-2026-109619. No code execution demonstrated. |
PHP 8.3 and later. |
|
CVE-2026-129474 |
Fatal error backtraces |
Use-after-free in magic method backtraces. |
PHP 8.5 and later, where fatal error backtraces are enabled by default. Setting zend.exception_ignore_args=1, the php.ini-production default, blocks the demonstrated attack. |
|
CVE-2026-129182 |
Fatal error backtraces |
Use-after-free. No code execution demonstrated. |
PHP 8.5, specific path-level settings, and an Apache per-directory configuration or front end that produces an early diagnostic. |
Who is affected
The vulnerable versions are PHP 8.2 before 8.2.36, 8.3 before 8.3.37, 8.4 before 8.4.28, 8.5 before 8.5.13, and the 8.6.0 release candidates. Whether a deployment is exposed depends on the conditions of each flaw.
PHP 8.1 and earlier are end-of-life. depthfirst says the official 7.4, 8.0 and 8.1 end-of-life mitigation branches are not affected by phpAfterShell, but PHP says CVE-2026-129289 was introduced in PHP 5.6.0 and that releases older than 8.2 may also be affected by CVE-2026-115560.
Linux distributions often backport fixes without changing the PHP version number. Check the full package version against your distribution's advisory.
How Cloudflare WAF protects you
PHP runs a large share of the web, often inside content management systems, plugins, and container images that teams do not update directly. Patching every PHP runtime takes time. Cloudflare WAF reduces your exposure while you patch.
phpAfterShell: protection on every plan
We released the original PHP remote code execution rules in an emergency release on October 21, 2026, after the php2shell vulnerabilities (CVE-2026-109618 and CVE-2026-109619) were disclosed. We extended them to CVE-2026-115560 on October 23 and refined them several times in the following weeks, based in part on reports from security researchers who took part in a PHP Capture the Flag (CTF) challenge.
phpAfterShell shares an attack technique with php2shell: an attacker plants serialized PHP data in session storage and waits for PHP to deserialize it. Because of that overlap, the existing rule already matched part of the phpAfterShell attack pattern before disclosure. On November 19, we updated the rule's detection logic to cover phpAfterShell and added CVE-2026-126714 to its description.
|
Rule description |
Rule ID |
Ruleset |
Default action |
|
PHP Remote Code Execution Attack (CVE-2026-109618, CVE-2026-109619, CVE-2026-115560, CVE-2026-126714) #6 |
19373a83abb840e18ab3ce5a7975ce1b |
Cloudflare Free Managed Ruleset (Free plan) |
Block |
|
PHP Remote Code Execution Attack (CVE-2026-109618, CVE-2026-109619, CVE-2026-115560, CVE-2026-126714) #6 |
4148ae686fdb4d01be673fab9d9c073d |
Cloudflare Managed Ruleset (Pro, Business and Enterprise plans) |
Block |
Free plan customers do not need to take any action. On paid plans, the rule is active wherever the Cloudflare Managed Ruleset is deployed. You can use the links in the Zero Wire briefing to go straight to the rules in your dashboard.
New rules for PHP-FPM and SOAP flaws
The three new rules are part of the Cloudflare Managed Ruleset (Ruleset ID efb7b8c949ac4650a09736fc376e9aee) and are available on Pro, Business and Enterprise plans.
|
Rule description |
Rule ID |
Default action |
|
PHP-FPM – CVE:CVE-2026-129289 |
8ef1c34a424b4ccfa6f6fe186c6f42b2 |
Log |
|
PHP SOAP – CVE:CVE-2026-15353 |
5c5a9d6397e44837a3214b5ba54028d4 |
Log |
|
PHP SOAP – CVE:CVE-2026-129506 |
00a23de67a684876ba67c5d44521b819 |
Log |
To review their matches, go to Security > Analytics > Events and filter by rule ID. If the matches are not legitimate traffic, change the rule action to Block: go to Security > Settings, edit the Cloudflare Managed Ruleset, search for the CVE identifier and set the rule action to Block, or you can refer to the links in the Zero Wire briefing to go straight to the rules configuration.
What the WAF cannot see
A WAF can block an exploit when the malicious data arrives in an HTTP request that passes through Cloudflare. It cannot block every path to these vulnerabilities, including:
- The deserialization step. phpAfterShell's final step happens inside PHP, when it reads a corrupted session file. The WAF can block the requests that plant the payload, not the read itself.
- Session data from other sources. If an application copies user-controlled data into the session from a database, a queue or an upstream API, that data may never cross the WAF in a recognizable form.
- Flaws triggered by server state. CVE-2026-129496, CVE-2026-129481, CVE-2026-129474 and CVE-2026-129182 depend on error logs, diagnostics and worker lifecycle. They do not have dedicated WAF rules, and the patch and the configuration changes below are the way to address them.
- Traffic that bypasses Cloudflare. This includes internal traffic between services and PHP-FPM listeners exposed directly to a network.
Adding defense in depth with WAF attack score
WAF attack score adds a machine learning layer that scores each request for attack payloads. It is available on Business plans (cf.waf.score.class) and, with a dedicated remote code execution sub-score (cf.waf.score.rce) along with an overall score (cf.waf.score), on Enterprise plans.
Attack score complements the managed rules. It will not recognize every serialized object or smuggled FastCGI record on its own, but a working exploit chain usually needs more than one request, and the later stages carry payloads the model is trained to score:
- Second-stage payloads. Once an attacker can run code, they still need to send commands: shell execution primitives (/bin/sh -c, system(), passthru()), PHP code evaluation (eval(), assert()) or reverse-shell strings in headers, query parameters or request bodies.
- Webshell traffic. Attackers often drop a small PHP webshell after the initial compromise. Requests that pass operating system commands to that webshell remain visible to attack score.
Deploy protections and patch
You can find more information on how to deploy managed rules and attack score in our WAF guide. In short:
- Check that phpAfterShell protection is active. On the Free plan, no action is needed. On paid plans, make sure the Cloudflare Managed Ruleset is deployed and that the PHP Remote Code Execution Attack #6 rule is set to Block.
- Review the new rules and switch them to Block. The CVE-2026-129289, CVE-2026-15353 and CVE-2026-129506 rules are in Log mode by default. Review their matches in Security Events, then change their action to Block.
- Layer attack score. Create a custom rule that blocks or challenges requests with a low remote code execution score, for example cf.waf.score.rce le 20 on Enterprise plans, or cf.waf.score.class eq "attack" on Business plans.
- Upgrade PHP. Move to 8.2.36, 8.3.37, 8.4.28, 8.5.13 or 8.6.0. Rebuild container images and restart the PHP-FPM master or Apache so every worker loads the new binary, then verify the version that serves web requests. After upgrading, check that no php.ini, FPM pool or virtual host still sets session.upload_progress.enabled=1, because an explicit setting overrides the new default.
- Apply interim mitigations if you cannot upgrade right away. Set session.upload_progress.enabled=0 and limit the untrusted data you store in sessions. Turn off FastCGI connection reuse. On PHP 8.5, set fatal_error_backtraces=0. Fix configuration errors that produce PHP startup warnings, or send PHP errors to syslog instead of a file. Keep PHP-FPM listeners off untrusted networks. These steps reduce exposure; they do not fix the flaws.
For a prompt you can give an AI agent to inventory your PHP deployments and check each one against all seven critical CVEs, see the phpAfterShell page on Cloudflare Zero Wire.
Update every PHP runtime now
phpAfterShell turns an interrupted file write in PHP's default session handler into a path to code execution, and it arrived in the same release as six other critical flaws. With technical details now public, we expect exploit attempts to follow. Cloudflare WAF blocks known phpAfterShell attack patterns for every customer, including the Free plan, and paid plans have new rules for the PHP-FPM and SOAP flaws. The fix is still to upgrade PHP and restart the services that use it.
How Bee implemented Zero Operator Access for personal AI on AWS
Post Syndicated from Gopinath Jagadesan original https://aws.amazon.com/blogs/architecture/how-bee-implemented-zero-operator-access-for-personal-ai-on-aws/
Bee, an Amazon company, is a personal artificial intelligence (AI) device you wear. It listens to your day, understands what happened, and remembers the commitments and ideas you would otherwise lose. Bee uses that understanding to give you help that’s tailored to your life. With Bee, you can:
- Get summaries of important conversations and moments.
- Recall past interactions when you need them.
- Capture commitments and follow-ups from meetings and client conversations.
- Spot patterns in your routines and relationships.
- Gain meaningful insights about your day.
To deliver these experiences, Bee handles conversations about health, finances, and family, some of the most personal parts of users’ lives. Bee securely manages this sensitive data so that it always remains protected. Bee built an architecture with no mechanism for operators (Bee engineers, other Amazon employees, and AWS infrastructure operators) to access customer data. Bee’s own controls cover the first two groups, and protection from AWS infrastructure operators is inherited from the AWS Nitro System. Bee calls this Zero Operator Access (ZOA). In this post, we show how Bee does all of this and share the AWS building blocks used to achieve ZOA.
Solution overview
The AWS shared responsibility model describes security as two domains: security of the cloud, which AWS is responsible for, and security in the cloud, which is the customer’s responsibility. AWS operator access controls are designed so that AWS personnel have no technical pathway to customer data. Bee applies the same principle to its own operators, Bee engineers and other Amazon employees. That means hardening every layer of the stack.
Bee’s core control is EC2 instance attestation: A user’s device releases the keys needed to decrypt their data only to instances running software it has verified. Attestation proves what runs inside an instance, but it can’t measure what surrounds it, such as which networks the instance can reach or who can change account permissions. So, Bee paired attestation-gated key release with network, storage, and organizational controls that close the paths attestation can’t measure. Figure 1 shows how these controls fit together. The sections that follow walk through each one.
Build time
- A transparency service, run by a separate Amazon team that Bee doesn’t control, keeps a copy of every approved Amazon Machine Image (AMI), container, and model for later audits. It publishes the expected measurements for each approved deployment to Sigstore Rekor, a public transparency log.
- The attestable AMI is shared to the Bee account, and the transparency proofs are stored in Amazon Simple Storage Service (Amazon S3).
- At boot, each instance records what it’s running in NitroTPM. It then gets a TLS certificate from AWS Private Certificate Authority (AWS Private CA) with its attestation and transparency proofs embedded. The Bee app checks this certificate before it shares any keys. If the software has changed, the app refuses to connect.
Runtime
- The Bee mobile app only connects to an attested instance over TLS.
- The instance presents its certificate. The app verifies the attestation against the AWS Nitro root and the transparency log.
- Only if they match does the app release a short-lived key. The key exists only in memory in the app servers and Redis key stores. Inference servers never receive keys.
- Data stored in Amazon Relational Database Service (Amazon RDS), Amazon ElastiCache, and S3 is encrypted before it leaves the boundary. AWS Lambda integrations receive plaintext only with the user’s consent.
Establish a verifiable compute foundation
The first problem Bee had to solve was trust. A user’s device needs to verify that Bee’s servers booted only with the approved software. That verification requires evidence rooted in a trusted mechanism outside the server application itself. Bee uses EC2 instance attestation to provide signed measurements of the instance’s boot software.
Bee builds its base images with an internal, hardened pipeline that produces attestable AMIs for Amazon Elastic Compute Cloud (Amazon EC2). During the build, the pipeline computes reference measurements offline from the Unified Kernel Image (UKI) and the Secure Boot configuration. These are the expected values for platform configuration registers (PCRs), which record cryptographic measurements during boot. Bee uses PCR4, PCR7, and PCR12 as verification targets. Because these values are computed without booting the image, Bee knows the expected measurements before any instance launches.
Following the AWS guidance on isolating data from your own operators, every Bee attestable AMI is built with these properties:
No interactive access. The image includes no SSH, SSM, or shell, so operators have no path into a running instance.
Only trusted software. The image contains only the components the workload needs, and every component is measured.
Read-only file system and ephemeral local storage. The root filesystem is read-only. Local instance storage is encrypted with a key held only in memory, and instances are replaced rather than rebooted, so no data outlives the instance.
At runtime, the bootloader and operating system measure the boot components and extend those measurements into NitroTPM PCRs. NitroTPM provides an attestation document containing the resulting values, signed by the AWS Nitro System through the AWS Nitro Attestation PKI. Any verifier can check these values against the approved reference measurements. With the same measured boot components and configuration, the selected PCR values remain consistent, making them suitable for remote verification.
Extend the chain of trust to your containers and data
A trusted OS is necessary but not sufficient because Bee’s application containers and model weights can change independently of the AMI. If an unauthorized user could swap a container image or a model file without detection, the attestation document would still show clean boot measurements even though the workload had been altered.
Bee solves this with a custom measured boot tool that runs before any application container starts. It resolves each Docker image in the manifest to its immutable Amazon Elastic Container Registry (Amazon ECR) digest. It also retrieves each Amazon Simple Storage Service (Amazon S3) artifact’s SHA-256 checksum. It computes a deterministic hash across the manifest, all container digests, and all artifact checksums, then extends NitroTPM PCR14 with this value. Any change to any container image, model weight, or the manifest itself produces a different PCR14 and a different attestation document.
Critically, PCR14 is extended before the NitroTPM attestation document is obtained. The attestation document that Bee’s application servers present to clients therefore reflects both the OS state (PCR4, PCR7, PCR12) and the workload state (PCR14) as a single signed hardware measurement.
Before deployment, the transparency service runs an independent signing process. It resolves the same ECR digests and S3 checksums, recomputes the expected PCR14, and commits the full PCR map to Sigstore/Rekor, an independent, publicly auditable transparency log. The resulting proof bundle is stored in regionally replicated S3 buckets so that verification at boot time is fully offline, with no runtime dependency on external infrastructure.
Validate attestation at every connection
At boot, the instance first confirms that its own measurements match the approved entry in the transparency log. If they don’t, it stops there. If they match, it requests a TLS certificate from AWS Private CA, with its attestation document and transparency proof embedded in the certificate. The attestation is tied to that certificate’s key, so it can’t be reused by another instance.
The user’s device decides whether to trust the instance. When it connects, it checks the embedded evidence offline against roots built into the app, including the AWS Nitro root. If the measurements don’t match an approved configuration, the client rejects the connection and shares no keys.
The same certificates protect traffic between instances over mutual TLS. Only roles that need to start connections, such as application servers, receive client certificates. Inference instances don’t, so they can’t reach key stores or other services.
Limit what the network can reach
All attested EC2 instances run in isolated subnets of an Amazon Virtual Private Cloud (Amazon VPC) with no internet egress. The only outbound paths are VPC endpoints to Amazon Relational Database Service (Amazon RDS), Amazon ElastiCache, and tightly scoped AWS Lambda functions. These functions handle external integrations such as email or push notifications. Lambda functions receive only data already encrypted with user keys. They never see plaintext.
Keep encryption keys out of persistent storage
Users’ encryption keys originate on their devices. After verifying an instance’s attestation, the device releases a short-lived, scoped key to that instance. The key exists only in memory, in the application instance and in Redis key stores running inside attested instances with persistence disabled. It expires after 7 days without user activity. Because AWS never holds this key, no storage layer, backup, IAM policy, or KMS grant can provide access to it.
Sensitive data is encrypted inside the attested instance before it reaches Amazon RDS, Amazon ElastiCache, or Amazon S3, so those services store only ciphertext. Plaintext stays inside the attested boundary. For the full key hierarchy and data flow, see the Bee Private Compute whitepaper.
Use AWS organizational controls to eliminate unilateral access
Strong technical controls also need strong permission boundaries. If one person could change those controls, they could be bypassed. Bee is designed so that no single team can do this. The Bee team manages the private CA and the deployment pipeline but doesn’t control the transparency service. The transparency team can commit entries to the Sigstore log but has no access to Bee’s AWS accounts. Deploying code that doesn’t appear in the public transparency log would require coordination across independent teams.
AWS Service Control Policies (SCPs) back this separation at the infrastructure level. SCPs apply across all Bee accounts, limit which actions are possible in each account, and need multiple levels of approval to change. This makes the separation of duties enforceable in AWS itself, not only through process. SCPs add defense in depth. The primary safeguard is still attestation: Any change to the software changes its measurements, and the Bee app refuses to connect to software it doesn’t recognize.
Conclusion
In this post, we showed how Bee implemented Zero Operator Access for personal AI on AWS. Users hold their own keys, so they decide who can read their data. Before the Bee app shares a key, it checks that the server is running approved, publicly logged software, and no operator or policy can override that check. Amazon EC2 instance attestation makes that check verifiable. Network isolation, ephemeral storage and organizational controls close the paths attestation can’t measure.
Next, Bee is moving its inference to Amazon Bedrock Mantle, which provides zero operator access as a managed capability. User-held keys and attested application servers will stay part of the Bee architecture, so data stays protected from Bee operators.
You can apply the same pattern to any workload that handles sensitive data. To get started:
- Read the EC2 instance attestation documentation.
- Follow the guide to isolating data from your own operators.
- Explore the full architecture in the Bee Private Compute whitepaper.
If you have a similar use case or want help building it, contact your AWS account team or reach out to AWS.
Further reading
Trail of Bits independently assessed the Bee Private Compute whitepaper, which covers the complete architecture, including client-side cryptography.
If your sensitive workloads run in containers, AWS Nitro Sandboxes give each Amazon EKS pod, Amazon ECS task,
or Amazon EC2 workload its own hardware-isolated VM, with attestation and zero operator access built in.
About the authors
Chinese-nexus actor’s Cairn AI agents found a zero-day on their own
Post Syndicated from CJ Moses original https://aws.amazon.com/blogs/security/chinese-nexus-actors-cairn-ai-agents-found-a-zero-day-on-their-own/
Amazon Threat Intelligence is sharing findings from an investigation into a Chinese-nexus threat actor using autonomous AI agents to conduct hacking operations with minimal human involvement. The actor gave the agents a simple goal: “obtain shell access.” During the campaign, the agents found a zero-day in an open-source application and used it to gain full control of a server. These findings show that agentic offensive operations are already happening, and defenders should prepare for the speed and persistence these tools enable.
Discovery
On September 10, 2026, Amazon Threat Intelligence identified a server with a publicly hosted instance of Cairn, an open-source autonomous AI penetration-testing framework, running without authentication. Because the operator left the server publicly accessible, the operational history of the platform was visible to anyone on the internet, including project configurations, actor prompts, and AI output. The operator wrote prompts in Simplified Chinese, and the timestamps in executed scripts were configured to China Standard Time.
Analysis of the instance revealed a campaign targeting IP addresses associated with universities in East Asia outside mainland China over an approximately 48-hour period beginning September 8, 2026.
Cairn and an overview of this campaign
Cairn was built as a research and problem-solving engine for defenders. Operating it is simple. Given a starting point and an objective in plain language, it coordinates multiple AI agents to find a path to that goal. That same ease of use makes it attractive to threat actors. In this campaign, the actor provided a list of targeted IP addresses with variations of the goal to “obtain shell access.” Based on those inputs, the AI agents planned, executed, and adjusted their approach as they learned, without the operator choosing each next step.
The campaign included several operations that varied widely in complexity and outcome. The following operations show both the persistence and the capability of autonomous AI agents.
Persistence against a hardened target
The most extensive operation targeted a Redis (remote dictionary server) instance at one university that was configured to allow access without authentication. Redis is a database that keeps frequently used data in memory so applications can retrieve it quickly, which can make it a valuable foothold inside a network. Over roughly 16 hours and 148 sequential actions, the agents worked through a long list of known techniques for taking control of an open Redis server. These included abusing Redis’s replication feature to load unauthorized code, escaping its scripting sandbox, writing to its configuration files, and corrupting its memory. The agents also attempted Log4Shell injection against another service running on the same system.
When those attempts failed, the agents mapped the internal Docker network topology through a server-side request forgery (SSRF) vulnerability in a co-located Qdrant instance and launched credential sprays against PostgreSQL, SSH, and several other services. None of these attempts succeeded.
A separate operation ran for more than 6 hours and targeted a university GPU server, which is a group of high-performance computers built for computing-intensive research. The agents first built a list of about 80 real usernames by researching the university’s public presence, including faculty directories, lab websites, archived web pages, and academic papers. Then, they tested more than 30,000 credential combinations against the server’s remote login (SSH), and, on other systems across the university network, an admin dashboard, a network storage device, a VPN server, and the university’s campus portal. They never found a working login.
Neither operation succeeded, yet together they show that the agents kept adapting for nearly a full day without human direction.
Zero-day discovery
Against a target running an open-source medical imaging AI application, the outcome was different. The agents identified the application’s framework, mapped its API endpoints, and found an upload endpoint with a filename parameter. They tested that parameter for path traversal, and the parameter was vulnerable. In about 11 minutes, the agents went from mapping the application’s API to arbitrarily writing files on the server.
In a later session, the agents used the same vulnerability to write a Python reverse shell payload to sitecustomize.py, a file Python automatically imports at interpreter startup. The agents then triggered a training API endpoint to spawn a new Python process. The new process imported the payload and established a reverse shell running as root.
At the time of discovery, this path traversal vulnerability in the medical imaging application did not correspond to any assigned security advisory and was unpatched. Amazon Threat Intelligence assesses with high confidence that it was a zero-day based on the absence of any corresponding fix, issue, advisory, or prior mention in vulnerability databases for the affected open-source project.
Subsequent use
In another session, the threat actor stepped in. After the agents discovered the zero-day, the actor then provided the agents with a proxy that tunneled into a second university network. The server that the proxy connected to was running the same vulnerable software, and we infer the actor had used the zero-day to compromise it and establish the tunnel. The actor directed the agents to use the tunnel to target other machines in that network.
Attribution
Amazon Threat Intelligence assesses with moderate confidence that this is a Chinese-nexus threat actor based on the Simplified Chinese prompts, the China Standard Time script timestamps, and the targeting of universities likely of strategic interest to China.
Actions taken by AWS
Amazon Threat Intelligence notified the project’s maintainers of the vulnerability, and they released a fix and a GitHub Security Advisory.
The affected organizations were non-AWS customers that AWS had no direct path to notify. Instead, AWS worked with a government partner to notify the organizations about the activity.
Adoption is growing
Gambit Security was one of the first organizations in the industry to document the use of Cairn by a threat group. Its research describes a separate, financially motivated actor using Cairn to target online retailers. Together, these cases show that this autonomous AI agent framework is being adopted in both espionage and criminal operations. Additional details are available in Gambit Security’s report.
What this means for defenders
The operational tempo in these cases compresses the window available for defensive response. An agent that discovers and exploits a zero-day in minutes completes its activity faster than many security operations centers can manually triage an alert. The agents that failed against the hardened Redis target ran continuously for 16 hours without breaks, sleep, or working-hour constraints. To keep pace, organizations should prioritize high-confidence detections that trigger automated response, with humans overseeing outcomes rather than reviewing every individual action.
Behind the scenes, AWS active defense systems use global honeypots (decoy systems that attract threat actors) and network traffic analysis to identify actors that are scanning for vulnerable systems, and then help restrict that activity at the network level. These protections are built into the AWS network at no extra cost to customers.
Indicators of compromise
The following addresses appear in records dated September 8 to 10, 2026.
142[.]4.98.145
142[.]4.107.34
If you have questions about this post, contact AWS Support or start a new thread on AWS re:Post.
The Real Reason Robert Pattinson Is the New James Bond
Post Syndicated from The Atlantic original https://www.youtube.com/shorts/ZceyMYUtdHw
Sorry, Robert Pattinson Is Not James Bond
Post Syndicated from The Atlantic original https://www.youtube.com/shorts/xrVZ2csrArg
This Is the Only Travel Router You’ll Ever Need (GL.iNet Mudi 7)
Post Syndicated from Crosstalk Solutions original https://www.youtube.com/watch?v=RfFsV-mTLuo
What’s So Important About Nvidia’s Chips?
Post Syndicated from The Atlantic original https://www.youtube.com/watch?v=P68tHQwDNuI
Will President Trump Work With Democrats in Congress?
Post Syndicated from The Atlantic original https://www.youtube.com/shorts/5MSfwrbXVxg
Conditions at Alligator Alcatraz #lastweektonight
Post Syndicated from LastWeekTonight original https://www.youtube.com/shorts/KGQEoZe5Jkk
[$] Bringing the Agama installer to openSUSE Tumbleweed
Post Syndicated from jzb original https://lwn.net/Articles/1107830/
The openSUSE Project has been working on
the Agama installer for four
years; it was the default installer for openSUSE Leap 16.0 when
it was released in 2025, and has been adopted by other openSUSE flavors as
well. Now the project is gearing up to go all-in on Agama for Tumbleweed, the rolling-release
edition that is meant to be where updates and new features land first. Even so,
the community has concerns about losing some of YaST’s legacy functionality and
the impact on installing Tumbleweed on systems that have less RAM.
