AWS Weekly Roundup: AWS Nitro Sandboxes, AWS Emulator, and more (November 16, 2026)

This post was originally published on this site

A second delivery of the same message can reveal more about an application than its happy-path demo. I like tools that make those cases easier to investigate while a change is still small. Last week’s launch of AWS Emulator brings part of that work onto your own machine: developers and coding agents can exercise AWS API interactions, inspect results, and try again without provisioning cloud resources for every attempt.

I wrote about the Emulator’s launch last week, and it’s my main highlight in this edition. There are also new ways to isolate workloads on shared infrastructure, give an agent narrowly scoped access to a backend, and prepare search applications for a regional disruption. Now, let’s get into this week’s AWS news…

Official AWS diagram showing application code, SDKs, CLI, and coding agents calling AWS Emulator on a laptop or CI environment, with a separate path for deployment to AWS.

AWS Emulator runs locally alongside your code and development tools. Image: AWS.

Headlines
Test your applications against AWS locally with AWS Emulator introduces a generally available local environment for AWS API interactions. Point the AWS CLI or AWS SDKs at its HTTPS endpoint, and your application keeps its normal SDK calls. The walkthrough shows a coding agent creating an Amazon DynamoDB table, writing an item, and reading it back. You don’t need an AWS account for emulated operations, and there is no additional service fee. The getting-started guide covers Linux packages, Docker for macOS and Windows, and agent-assisted setup; the source is on GitHub.

What I like is giving an agent concrete feedback while it works: run calls, inspect results, and revise the code. Matt Wood’s perspective on feedback for coding agents explores why that loop matters. Check the published fidelity results for your operations, because coverage varies and unimplemented calls return HTTP 501. The emulator doesn’t reproduce IAM and resource-policy enforcement or cross-account and cross-Region behavior, so test the complete application and its security configuration on AWS before production.

AWS Nitro Sandboxes bring hardware isolation to pods, tasks, and VMs. You can give an Amazon EKS pod or Amazon ECS task its own VM boundary while sharing an Amazon EC2 instance. That is useful for tenant workloads, build jobs, and agents executing generated code. Isolated mode separates workloads from their neighbors; confidential mode adds protection from node operators and cryptographic attestation. The Compute Blog deep dive explains both modes and their integrations. Nitro Sandboxes have no additional charge on supported instances; EC2 and applicable EKS Auto Mode or ECS Managed Instances fees still apply.

Last week’s launches
Here are some launches and updates from this past week that caught my attention:

Amazon Cognito supports OAuth 2.0 token exchange – You can now exchange a user’s token for one scoped to a downstream service in Amazon Cognito. The derived token can have narrower permissions and a single audience, with no refresh token; supplying an actor token also identifies the intermediary in an act claim. For an agent calling a backend on someone’s behalf, that makes delegation more explicit without forwarding the original token. The feature is available on Essentials and Plus plans in all Cognito Regions.

Claude Fable 5.2 is available on AWS – You can access the model through Amazon Bedrock or Claude Platform on AWS. Anthropic positions it as its most capable generally available model for technical work, including extended engineering tasks, scientific research, and quantitative finance. Bedrock has model-specific retention requirements: Fable 5.2 traffic is retained for up to 30 days for abuse detection, with a temporary zero-retention exception for eligible internal use.

Amazon ElastiCache Serverless adds search and aggregations – You can now combine vector, full-text, and hybrid search with server-side aggregations in Amazon ElastiCache Serverless for Valkey. That gives product discovery, recommendations, and agent-memory retrieval another option for querying frequently changing data. The capability requires Valkey 9, so create a compatible cache or upgrade an existing one. It is available in commercial Regions, AWS GovCloud (US), and the AWS European Sovereign Cloud.

Amazon OpenSearch Service adds managed cross-Region disaster recovery – You can now pair Amazon OpenSearch Service domains running version 3.7 or later in two Regions within one account. AWS specifies recovery objectives under one minute for data loss and under 20 minutes for recovery time. Planned switchovers preserve all writes; unplanned failovers can lose unreplicated data. The deep dive covers the remaining work: keeping configuration aligned and redirecting application writes after switching roles, plus secondary-domain and data-transfer charges.

Amazon CloudWatch Logs adds account-level retention policies – You can now set retention across all log groups or groups matching a name prefix in Amazon CloudWatch, with policies covering existing groups or only new ones. When policies overlap, the longest retention period applies. A platform team can set a baseline and retain security logs longer without updating every group individually. The feature has no additional charge and is available in commercial Regions except Middle East (Bahrain) and Middle East (UAE).

The next generation AgentCore runtime is now the default – New Amazon Bedrock AgentCore runtimes now use the next-generation runtime by default, so agent sessions start in under 2 seconds, scale up to 8 vCPU and 32 GB, scale to zero when idle, and bill up to 68% less memory, while each session still runs in its own isolated microVM.

For a full list of AWS announcements, be sure to keep an eye on the What’s New with AWS page.

Other AWS news
Here are some additional posts and resources that you might find interesting:

Optimizing cost per task and proving agent ROI on Amazon Bedrock – This guide follows an agent’s cost through repeated calls, reasoning, caching, and human review. I like its emphasis on measuring a completed task and comparing outcomes against a documented baseline. Its worked prices are illustrative; use your own workload and reconcile estimated costs with billing data.

How Zillow runs 100 million daily notifications on AWS Step Functions – Zillow describes reusable content modules and configuration-driven AWS Step Functions Express Workflows for more than 100 million daily notifications. The useful engineering details include idempotent modules, batching, campaign isolation, and testing expressions with the TestState API before deployment. Those patterns apply well beyond notification systems.

Upcoming AWS events
Check your calendar and sign up for upcoming AWS events:

AWS re:Invent – Join the community in Las Vegas from November 30 to December 4. Browse more than 2,200 sessions, including workshops and deep dives, or register for the free livestream to follow keynotes and selected sessions remotely.

AWS Community Days – Find community-led technical talks, workshops, and hands-on learning near you. Check each organizer’s page for current dates and registration details.

Join the AWS Builder Center to connect with builders, share solutions, and access content that supports your development. Browse here for upcoming AWS-led in-person and virtual events and developer-focused events.

That’s all for this week. Check back next Monday for another Weekly Roundup!

– Daniel Abib

This post is part of our Weekly Roundup series. Check back each week for a quick roundup of interesting news and announcements from AWS!

Scans for LiteLLM/Starlette (CVE-2026-42271, CVE-2026-48710), (Mon, Nov 16th)

This post was originally published on this site

This weekend, we started seeing requests for /mcp-rest/test/tools/list hitting our honeypots. These requests appear to attempt to exploit CVE-2026-42271 and CVE-2026-48710. Horizon3.ai published a short write-up about how these vulnerabilities can be chained to achieve remote code execution without authentication [Horizon3]

Macfinger ClickFix campaign sends DownTheDRAIN infostealer for macOS, (Fri, Nov 13th)

This post was originally published on this site

Introduction

In this diary, I've given a nickname to the macOS infostealer we've been seeing from the Macfinger ClickFix campaign. Based on the analysis of an example posted on the Huntress Cybersecurity Blog, I'm calling this macOS malware DownTheDRAIN infostealer.

This diary reviews an example of DownTheDRAIN infostealer distributed through the Macfinger ClickFix campaign on Wednesday, 2026-11-11.

Of note, my mac mini running macOS 26.7.3 blocked and moved the malware to Trash before it could exfiltrate any sensitive data.


Shown above: DownTheDRAIN infostealer blocked and moved to Trash.

Background

I first wrote about the Macfinger ClickFix campaign on 2026-09-22, and I took a closer look at the malware on 2026-09-25. It didn't match the profile of any macOS infostealers I usually run across. Since I couldn't find any unique characteristics in my analysis, I waited for someone to name it.

I didn't see that anyone had named this infostealer yet, but the Huntress analysis of a sample provided a somewhat unique aspect that could be used for a nickname.

The DRAIN function

The Huntress analysis from one of the samples revealed a DRAIN function that "…identifies various cryptocurrency wallet addresses and can redirect the contents to a wallet controlled by the threat actor." For more information on this function and the associated code, read the full August 2026 post by Andrew Brandt.

Images


Shown above: Fake CAPTCHA page from the Macfinger ClickFix campaign.


Shown above: Fake CAPTCHA page showing the ClickFix instructions.


Shown above: ClickFix text pasted into a Terminal window.


Shown above: Traffic from the infection filtered in Wireshark.

Indicators

Macfinger domain for the fake CAPTCHA page:

  • quill-kraee-um2gf[.]pro

Infection traffic for DownTheDRAIN infostealer:

  • hxxp[:]//45.150.32[.]130/37339606cba4522a?force=1
  • hxxp[:]//45.150.32[.]130/4be1066a49e75?force=1
  • hxxp[:]//171.22.131[.]24:8133/api/t  <– HTTP POST request, generated 4 times before the malware was blocked

Files from the infection:

SHA-256 hash: 58e503cc2e6aacc6bdba54f40a7edebf7a5362bef0a9039769baaba8c472c4db

  • File size: 5,011 bytes
  • File type: Bourne-Again shell script text executable, ASCII text, with very long lines
  • File location: hxxp[:]//45.150.32[.]130/37339606cba4522a?force=1
  • File description: Retrieved by command in ClickFix text, this shell script installs DownTheDRAIN infostealer

SHA-256 hash: 8b5026d841aa93758ec3cb55c276f84d3ec1cf459810e0d9aa5624e2776f2fcd

  • File size: 35,143,984 bytes
  • File type: Mach-O 64-bit executable arm64
  • File location: hxxp[:]//45.150.32[.]130/4be1066a49e75?force=1
  • File description: DownTheDRAIN infostealer binary retrieved by the above shell script

SHA-256 hash: c34cc30cb1cff5c47d77e62a3ba63e9a183989ec1ccdf7929beb1bcae0d41f23

  • File size: 34,957,760 bytes
  • File type: Mach-O 64-bit executable arm64
  • File location: $HOME/Library/Caches/com.apple.update
  • File description: DownTheDRAIN infostealer saved to the infected host, then blocked and moved to Trash by macOS

—
Bradley Duncan
brad [at] malware-traffic-analysis.net

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.

Exploit Attempts for GPUStack Authentication Bypass (CVE-2026-102895), (Thu, Nov 12th)

This post was originally published on this site

CVE-2026-102895 is a trivial authentication-bypass vulnerability. GPUStack is also an attractive target. It is open-source software that manages clusters of GPUs, which are typically used to run AI workloads. All versions of GPUStack prior to 2.2.0, which was released at the end of June. This vulnerability was not made public until the end of July, and the CVE was assigned on November 4th. 

Test your applications against AWS locally with AWS Emulator

This post was originally published on this site

Today we’re announcing AWS Emulator, a local emulator for Amazon Web Services (AWS) that you run on your machine. The AWS Command Line Interface (AWS CLI), the AWS SDKs, and your coding agents speak to it over a local HTTPS endpoint using the same AWS APIs they would use in the cloud, from your laptop. AWS Emulator has no additional service fee. You pay only for AWS resources when you deploy on AWS. Its source is on GitHub. You install it from an RPM or Debian package on Linux, and on macOS and Windows you run it in Docker.

How it works
You install the emulator, start it, and point your tools at the local endpoint. When AWS Emulator starts, it generates its own credentials, a config file, and a certificate, and writes them to ~/.aws/emulator/9297/. You set environment variables so the AWS SDK talks to your laptop instead of AWS, and your application code stays unchanged.

From there, your existing tests, CLI scripts, and coding agents keep working the way they already do. A unit test that creates an Amazon DynamoDB table, writes an item, and reads it back is the same test, and it runs on your machine without a deployment. A coding agent can create resources, check the result, and iterate again without waiting on a deployment in a Region.

The emulator is implemented in Rust so that it stays light on CPU and memory on a laptop. It supports the APIs of AWS services that have an API model in the AWS API models repository on GitHub, and because it’s built from those models, the same ones the AWS SDKs use, your requests and the errors you get back have the same shape as on AWS.

If you are a developer, especially one working with coding agents such as Kiro or Claude Code, you can use that loop to test AWS interactions of real complexity locally.

Let’s try it out
To get started, I installed the package on Amazon Linux 2023. The package adds the aws-emulator command to /usr/bin/, so it’s on the path.

PKG=https://downloads.aws.com/aws-emulator/packages/aws-emulator/LTS/latest
sudo dnf install -y $PKG/aws-emulator-x86_64.rpm

aws-emulator -v

On macOS and Windows, you build a Docker image from the short Dockerfile in the documentation and run the emulator in a container. We don’t publish a ready-made image.

I started the emulator with aws-emulator. It serves HTTPS on 127.0.0.1:9297, so only my own computer can reach it, and it writes its log as JSON lines that show the address, the config file, and the certificate file.

aws-emulator

In another terminal, I set the environment variables that point the AWS CLI at the emulator, and unset any variables that could supply real AWS credentials.

export AWS_ENDPOINT_URL=https://127.0.0.1:9297
export AWS_SHARED_CREDENTIALS_FILE=~/.aws/emulator/9297/emulator_credentials
export AWS_CONFIG_FILE=~/.aws/emulator/9297/config
export AWS_EC2_METADATA_DISABLED=true
export AWS_DISABLE_HOST_PREFIX_INJECTION=true
export AWS_REGION=us-east-1
export AWS_DEFAULT_REGION=us-east-1
unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN AWS_PROFILE

The emulator generates new keys each time it starts. Its access key IDs start with EMULATOR, so you can’t mistake them for real AWS keys, and it rejects requests signed with any other keys. To confirm that my shell was talking to the emulator, I checked the health endpoint and the caller identity. The emulator uses a single account, 000000000000.

curl --cacert ~/.aws/emulator/9297/ca.pem https://127.0.0.1:9297/__admin/health

aws sts get-caller-identity

Then I created a bucket, copied in a small object, and listed it.

$ aws s3 mb s3://local-getting-started
make_bucket: local-getting-started

$ echo "hello from the emulator" > hello.txt

$ aws s3 cp hello.txt s3://local-getting-started/
upload: ./hello.txt to s3://local-getting-started/hello.txt

$ aws s3 ls s3://local-getting-started/

With the AWS CLI pointed at my laptop, I had the same commands I already use and a local endpoint that answered them.

Next I wanted to see it the way I actually work now, so with the emulator still running I opened Kiro and asked it to create an Amazon DynamoDB table, write an item, and read it back, all against AWS Emulator rather than my AWS account.

kiro> Using the local AWS Emulator (the environment variables
      are already set in this shell), create a DynamoDB table
      "kiro-demo" with a string key "id", put an item
      {id: "item-1", msg: "hello from kiro"}, then read it
      back with get-item.

$ aws dynamodb create-table --table-name kiro-demo 
    --attribute-definitions AttributeName=id,AttributeType=S 
    --key-schema AttributeName=id,KeyType=HASH 
    --billing-mode PAY_PER_REQUEST

$ aws dynamodb put-item --table-name kiro-demo 
    --item '{"id": {"S": "item-1"}, "msg": {"S": "hello from kiro"}}'

$ aws dynamodb get-item --table-name kiro-demo --key '{"id": {"S": "item-1"}}'

To use the same setup with an existing test suite, I would start the emulator, set the same environment variables in the script that runs the tests, and run them as usual.

Using the emulator in process
Running the emulator as a local process gives you an HTTPS endpoint that works with the AWS CLI and the AWS SDKs through environment variables. Some SDKs need an extra setting to trust the emulator certificate, for example a trust store for the AWS SDK for Java. For tests, there is a second option. AWS Emulator ships an embedded mode that you instantiate directly inside your test process and wire into the SDK through its HTTP client, rather than talking to a separate server over the network. Each embedded instance keeps its own state, so tests do not share buckets, tables, or queues, and you can run many of them in parallel. Embedded mode is available for the AWS SDK for Rust. You add the aws-emulator-embedded crate from GitHub to the [dev-dependencies] section of your Cargo.toml file. The following example creates an Amazon DynamoDB table, writes an item, and reads it back, entirely in process.

use aws_emulator_embedded::{AwsEmulatorEmbedded, EmbeddedOptions};
use aws_sdk_dynamodb::types::{
    AttributeDefinition, AttributeValue, BillingMode, KeySchemaElement, KeyType,
    ScalarAttributeType,
};

#[tokio::test]
async fn put_then_get_returns_the_item() {
    let emulator = AwsEmulatorEmbedded::new(EmbeddedOptions::default());
    let config = aws_config::defaults(aws_config::BehaviorVersion::latest())
        .http_client(emulator.http_client())
        .region(aws_config::Region::new("us-east-1"))
        .credentials_provider(emulator.aws_credentials_provider())
        .load()
        .await;
    let ddb = aws_sdk_dynamodb::Client::new(&config);

    ddb.create_table()
        .table_name("emulator-demo-table")
        .attribute_definitions(
            AttributeDefinition::builder()
                .attribute_name("id").attribute_type(ScalarAttributeType::S)
                .build().unwrap())
        .key_schema(
            KeySchemaElement::builder()
                .attribute_name("id").key_type(KeyType::Hash)
                .build().unwrap())
        .billing_mode(BillingMode::PayPerRequest)
        .send().await.unwrap();

    ddb.put_item()
        .table_name("emulator-demo-table")
        .item("id", AttributeValue::S("item-1".into()))
        .item("msg", AttributeValue::S("hi".into()))
        .send().await.unwrap();

    let got = ddb.get_item()
        .table_name("emulator-demo-table")
        .key("id", AttributeValue::S("item-1".into()))
        .send().await.unwrap();
    assert_eq!(got.item().unwrap().get("msg").unwrap().as_s().unwrap(), "hi");
}

When it runs as a local process, the emulator requires every request to be signed with Signature Version 4 (SigV4), the same way AWS does, and it exposes a /__admin/health endpoint on the same port so a script or a container can wait until it is ready before running tests. By default it also sends anonymous usage and error data, and you can turn it off.

How we measure fidelity
An emulator is only useful if a test that passes against it would also pass against AWS, so we measure that directly with fidelity tests. A fidelity test is a short program that uses an AWS SDK to run a workflow, such as storing an object and then reading and deleting it, and asserts how AWS behaves. We verify each fidelity test against real AWS. A fidelity test passes only if the emulator matches AWS on the response to every call, including the status code, the body, and the exact error code and message, and on the resources and data that the workflow creates.

With each release, we publish how many fidelity tests pass for each service, as k of n. For example, 40 of 50 means that 40 of the service’s 50 fidelity tests pass. The set of fidelity tests is public in the aws-emulator-evaluation-suite repository on GitHub, including the ones that don’t pass yet, so you can see what we verified and run the fidelity tests yourself. Read a score as a snapshot of a product that’s improving. When we add fidelity tests, a score can go down even while the emulator gets better.

If the emulator doesn’t implement an operation yet, it returns HTTP 501 (Not Implemented), so your tests fail right away. If the emulator acts differently from AWS, you can tell us by opening an issue in the AWS Emulator repository on GitHub.

How the emulator is built
AWS Emulator is built and maintained by agents from the AWS API models using Amazon Bedrock AgentCore Runtime Instances, AWS CodePipeline, and AWS CodeCommit, so it stays current with AWS as those models change.

One group of agents looks for gaps, both by comparing emulator responses against real AWS and by statically comparing the emulator’s code against the published Smithy models, and files an issue for each gap it finds. Another group picks up an issue, writes tests, implements the behavior, and reviews the change for correctness, performance, and security. When the change is ready, it is pushed to a source repository, and that push triggers an AWS CodePipeline run that runs the fidelity tests before the change is published to the public GitHub repository.

How we keep it secure
Because the code is written by agents, an independent security agent reviews changes adversarially, both while the fix is being made and again in the release pipeline as a final check before anything ships.

Security of your own use remains a shared responsibility. We build the emulator to run safely on your machine: it listens only on your own computer by default and rejects requests that aren’t signed with its own keys. You decide where it runs, what data you put in it, and how you test before production. Don’t use the emulator to test whether your application is secure. It doesn’t evaluate AWS Identity and Access Management (IAM) policies and resource-based policies the way AWS does, so a request that AWS denies might succeed in the emulator. Keep real credentials out of the environment of your test jobs, and test your security settings and your whole application on AWS before you go to production.

Now available
AWS Emulator is generally available today. It has no additional service fee. You pay only for AWS resources when you deploy on AWS. You can install it from RPM or Debian packages on Linux, run it in Docker on macOS and Windows, or build from source, and it works with the AWS SDKs and the AWS CLI once you set environment variables. At launch, it has some limits. It doesn’t evaluate IAM policies the way AWS does, and each emulator acts as a single account, with no cross-account or cross-Region behavior. How closely it matches AWS varies by service and feature. To see how well the emulator covers the services that you use, check the fidelity scores in the AWS Emulator documentation.

If you want to check regional availability, visit the AWS Capabilities by Region page in AWS Builder Center. If you want to call APIs, search documentation, find regional availability, and check troubleshooting about this new feature, try using the AWS MCP Server and plugins with your preferred AI tool.

To get started, see the AWS Emulator documentation.

Announcing PowerShell 7.7 GA Release

This post was originally published on this site

We’re excited to announce the General Availability of PowerShell 7.7, the next Standard Term Support
(STS) release of PowerShell. PowerShell 7.7 is built on .NET 11, continuing the alignment between
PowerShell and the modern .NET platform.

PowerShell 7.7 focuses on security hardening, new and improved commands, and reliability across the
engine, remoting, and interactive shell experience.

Notable areas of improvement include:

  • Security hardening across Constrained Language Mode, remoting, and help
  • New commands and parameters
  • More predictable handling of switch parameters
  • Startup, tab completion, and file system fixes
  • Module updates

For support dates, see the PowerShell support lifecycle article.

Highlights

  • PowerShell 7.7 is built on .NET 11
  • PowerShell 7.7 includes updates to the following modules:
    • Microsoft.PowerShell.PSResourceGet
    • Microsoft.PowerShell.Archive
  • New and improved commands
    • Added the New-TemporaryDirectory cmdlet
    • Added the -Extension parameter to Join-Path
    • Added the -ExcludeProperty parameter to Format-Table, Format-List, and Format-Custom
    • Get-AuthenticodeSignature now returns a SubjectAlternativeName property
    • Added a ToRegex() method to WildcardPattern
    • New-Guid now generates version 7 (time-sortable) UUIDs by default
  • Security hardening
    • Additional protections for Constrained Language Mode, including property assignment on
      non-core objects
    • Stronger argument and frame validation in PowerShell remoting, and restored schema validation
      in the CIM cmdlets
    • Implicit remoting protections now apply to resolved aliases
    • Stricter validation when extracting updatable help
    • Tighter file permissions for the fallback temporary home directory on Unix platforms
    • Test-Json no longer resolves external schema references unless you ask it to
  • More predictable switch parameters
    • Explicit -Switch:$false values are now respected by Split-Path, New-PSSession,
      Test-Connection, Get-TimeZone, Get-Random, Get-SecureRandom, Get-Uptime, and
      New-Guid, and by the operator parameters of Where-Object
  • Reliability and quality improvements
    • A damaged or unreadable per-user powershell.config.json no longer stops PowerShell from
      starting
    • Fixed Resolve-Path -Relative for names that begin with a dot
    • Fixed duplicate results from Get-Command fuzzy matching
    • Fixed Clear-Host for remote Windows sessions from non-Windows platforms
    • Fixed tab completion of positional parameters and completion for $PSBoundParameters.Keys
    • Improved handling of custom argument completers that return empty or null results
    • Fixed pwsh -file dot-sourcing of advanced-function scripts
    • Fixed progress bar rendering for double-width Unicode characters
  • Telemetry now respects the Windows diagnostics and feedback setting

A quick example

New-TemporaryDirectory creates a uniquely named directory in the system temp folder and returns a
DirectoryInfo object. Use -Prefix to make the directory easier to recognize:

# Create a uniquely named directory in the system temp folder
$workDir = New-TemporaryDirectory -Prefix build
$workDir.FullName

# Remove it when you're done
Remove-Item -LiteralPath $workDir.FullName -Recurse

Breaking changes

PowerShell 7.7 includes a small number of breaking changes. Review them before you upgrade
production scripts.

  • New-Guid generates version 7 (time-sortable) UUIDs by default instead of version 4. Use
    [guid]::NewGuid() when you need a fully random GUID.
  • Format-Table, Format-List, and Format-Custom now validate that -Property is not null or
    empty.
  • Null-or-empty argument validation now throws System.ArgumentException.
  • Explicit false values for Where-Object operator switches, such as -EQ:$false, are now handled correctly.

Other behavior changes

These changes might also affect existing scripts:

  • The update notification feature was removed from PowerShell.
  • Test-Json requires -FetchExternalReference to resolve external schema references.
  • Export-Csv no longer accepts -Append together with -NoHeader. Using -NoTypeInformation
    on the CSV cmdlets now writes a deprecation warning and has no effect.
  • Get-ChildItem -Name with -Recurse now returns matching files in subdirectories when the path
    contains a wildcard or names a file.
  • Constrained Language Mode restricts property assignment on non-core objects, including through
    ForEach().

Community contributions

PowerShell is built by a global community of users and contributors. Thank you to everyone who
filed issues, tested previews, improved docs, and submitted fixes during the PowerShell 7.7
release cycle.

We want to give a special thanks to the community members who spent the most time helping
others in the repository this release:

  • Top pull request commenters: @iSazonov, @muffy86, and @KirtiRamchandani
  • Top issue commenters: @mklement0, @237dmitry, and @rhubarb-geek-nz

The following individuals contributed code to the PowerShell 7.7 release:

  • @adamdriscoll, @amritanand-py, @behradbhrmi, @cuiweixie, @jborean93
  • @jorgeasaurus, @kasperk81, @KirtiRamchandani, @logiclrd, @MartinGC94
  • @MathiasMagnus, @mikkas456, @powercode, @reabr, @rwp0
  • @scuzqy, @SufficientDaikon, @ThioJoe, @trackd, @xtqqczze
  • @yotsuda, @yuunnn

Call to action

Install PowerShell 7.7 now.

For more information, see the following articles:

Looking ahead

We continue to work on future releases of PowerShell. Preview releases will continue to provide
early access to new capabilities and improvements, and your feedback on them helps us ship with
confidence.

PowerShell Team

The post Announcing PowerShell 7.7 GA Release appeared first on PowerShell Team.

Apple Patches Everyting: November 2026 Edition, (Tue, Nov 10th)

This post was originally published on this site

 

On Monday, Apple released updates for iOS/iPadOS, macOS, watchOS, and visionOS. These updates fix nine different vulnerabilities. One of the vulnerabilities, CVE-2026-113971, applies only to iOS/iPadOS version 26. Several of the vulnerabilities apply to Bluetooth issues that may weaken the device pairing process. 

The number of vulnerabilities Apple patches remains small, but Apple has increased the cadence of its updates.

 

iOS 27.2.1 and iPadOS 27.2.1 iOS 26.7.3 and iPadOS 26.7.3 iOS 18.7.12 and iPadOS 18.7.12 macOS Golden Gate 27.2.1 macOS Tahoe 26.7.3 macOS Sequoia 15.8.3 watchOS 27.2.1 watchOS 26.6.1 visionOS 27.2.1
CVE-2026-113960: A user added to an iMessage group may be able to access messages sent before they joined.
Affects Messages
x x   x x x x   x
CVE-2026-113961: A remote attacker may be able to join an iMessage group chat and receive its messages.
Affects Messages
x x   x x x x   x
CVE-2026-113963: An app may be able to access sensitive user data.
Affects App Intents
x           x   x
CVE-2026-113964: An attacker in Bluetooth range may be able to bypass the rate limit on pairing code attempts and pair with a device without user interaction.
Affects CoreUtils
x x x x x x x x x
CVE-2026-113965: A malicious Bluetooth device may be able to establish a pairing without user interaction.
Affects CoreUtils
x x x x x x x x x
CVE-2026-113968: An attacker in Bluetooth range may be able to bypass the rate limit on pairing code attempts.
Affects AirPlay
x x x x x x x x x
CVE-2026-113969: An attacker on the same network may be able to bypass the rate limit on AirPlay pairing code attempts.
Affects rapportd
x x x x x x x x x
CVE-2026-113970: An attacker in Bluetooth range may be able to corrupt process memory.
Affects Bluetooth
x x x x x x x x x
CVE-2026-113971: An attacker with physical access may be able to pair a device with an AirPlay receiver from the lock screen.
Affects MediaRemote
    x            

—
Johannes B. Ullrich, Ph.D. , Dean of Research, SANS.edu
Twitter|

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.

Attackers Searching for SAP Netweaver Webshells, (Mon, Nov 9th)

This post was originally published on this site

Just saw a new (to me) URL in our honeypot data today:

/irj/servlet_jsp/irj/root/ant.jsp

This request is part of a larger campaign to exploit SAP NetWeaver or to find already installed webshells.

The exploited vulnerability is "old": CVE-2025-31324. A perfect 10 CVSS score and the simple ability to upload files without authentication. Attackers have been using this vulnerability to upload webshells. Usually, these webshells end up in /irj/servlet_jsp/irj/root/. 

One particular attacker, 82.26.72.21, is hitting the following URLs. Not all of these URLs are SAP NetWeaver-related. Also, check the odd misspelling of "upload.aspx" at the end.

 

URL Path
/
/_layouts/15/start.aspx
/_layouts/15/ToolPane.aspx?DisplayMode=Edit&a=/ToolPane.aspx
/amp/upload
/ant.aspx
/ant.jsp
/ant.jsp/
/ant.php
/api/upload
/api/v1/upload
/authenticationendpoint/ant.jsp
/commandcenter/ant.jsp
/commandcenter/deployWebpackage.do
/developmentserver/metadatauploader?CONTENTTYPE=MODEL&CLIENT=1
/en-US/static/app/search/ant.php
/fileupload/toolsAny
/hosted/amp/upload
/images/ant.php
/images/pagebuilder/ant.php
/index.action
/index.php?option=com_baforms&task=uploader.upload
/index.php?option=com_gridbox&task=uploader.upload
/index.php?option=com_jce&task=plugin.display&plugin=browser
/index.php?option=com_sppagebuilder&task=media.directUpload
/irj/servlet_jsp/irj/root/ant.jsp
/m/webadmin/upload
/MagicInfo/ant.jsp
/MagicInfo/servlet/SWUpdateFileUploader
/NmConsole/ant.aspx
/NmConsole/Wug/Report/ExportReport
/Synchronization
/te/upload
/upload.apsx
/upload.aspx

 

—
Johannes B. Ullrich, Ph.D. , Dean of Research, SANS.edu
Twitter|

(c) SANS Internet Storm Center. https://isc.sans.edu Creative Commons Attribution-Noncommercial 3.0 United States License.

Scans for Sshole Vulnerability (CVE-2026-123158), (Sun, Nov 8th)

This post was originally published on this site

Our honeypots use "Cowrie" to collect SSH data. With the emergence of the "sshole" vulnerability last week, we are now seeing an increase in attempts to exploit the vulnerability. Our data is a bit limited in this respect. Our honeypots collect only the first 255 characters of SSH passwords. Longer passwords are highly unusual and not used for the usual password brute-forcing we observe.

Vulnerability Scans for Older Cisco IOS Vulnerability / Opt-Out Headers, (Thu, Nov 5th)

This post was originally published on this site

This morning, I was browsing our honeypot data for any new and existing PHP exploit attempts. Instead, I first ran into some GeoServer exploits, but found them to be too boring to write up. This Cisco IOS exploit attempt was a bit more interesting. Still nothing new. I suspect this is for CVE-2023-20198.