The servers are patched. The runtime version on every host is up to date. The ticket is closed.
And for some applications, that is not enough. The November 10, 2026 servicing release for .NET included two fixes where Microsoft says explicitly that updating the runtime does not resolve the issue. One lives in a NuGet package. The other lives in code that a template generated into your project, possibly years ago. Neither one is touched by the runtime installer, a server patch window, or a container base image refresh. Let's dive in!
What Shipped on November 10th
I am working from Microsoft's announcement, .NET and .NET Framework November 2026 servicing updates. The release produced .NET 10.0.15, 9.0.23, and 8.0.34, landed alongside the .NET 11.0.0 release, and the security table lists 25 CVEs across those versions. Check the linked MSRC entries for severity ratings and full details; I am only repeating what the announcement says.
Two entries carry instructions that go beyond "install the update":
- CVE-2026-118747 (.NET denial of service, listed for .NET 8, 9, 10, and 11). The announcement says this one requires a separate
System.Formats.CborNuGet package update. For the .NET 9 package line, the fix is in package version 9.0.24, not 9.0.23, and installing runtime 9.0.23 alone does not fix it. You update the package, then rebuild and redeploy. - CVE-2026-118741 (ASP.NET Core elevation of privilege, listed for .NET 8, 9, and 10). The announcement says this affects ASP.NET Core Identity scaffolding and templates. You update the scaffolding or template packages, or the SDK that supplies the templates, and then correct, rebuild, and redeploy previously generated applications. Updating the runtime does not repair generated code.
I like to think about patching in three layers: the runtime, the packages your app carries with it, and the code that was generated into your repository. Each layer has a different fix, and a different person usually owns it. Most teams already have a process for the runtime layer, so this post focuses on the other two.
Layer 1, Briefly: The Runtime
Install the update and restart the process. Self-contained apps and containers carry their own runtime, so they need a rebuild and redeploy rather than a host update. If you want proof of what is actually running, log it once at startup:
using System.Runtime.InteropServices;
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.Logger.LogInformation(
"Starting on {Framework} ({OS})",
RuntimeInformation.FrameworkDescription,
RuntimeInformation.OSDescription);
app.Run();
Your logs now answer "which runtime is production really on?" without anyone logging in to a server. Keep that information in your logs, not on a public endpoint.
Layer 2: Find the Vulnerable Package Before Your Users Do
Most teams never reference System.Formats.Cbor directly. That is the problem. If it is in your app, it probably arrived as a transitive dependency of something else, and nobody on the team has ever typed its name.
Is it in my dependency graph at all?
The dotnet nuget why command answers exactly that question, and shows the path that brought the package in:
dotnet nuget why MySolution.sln System.Formats.Cbor
Swap in your solution or project file. If the command reports that the package isn't in the graph, this CVE isn't your concern for that solution. If it is there, the output tells you which of your direct references pulled it in, which matters for the fix below.
What else is vulnerable right now?
While you are in there, ask the broader question. This lists every package with a known vulnerability, including transitive ones:
dotnet package list --include-transitive --vulnerable
Two notes. --include-transitive is not the default, and without it you only see the packages you reference directly. And dotnet package list is the newer noun-first form of the command; on older SDKs, dotnet list package takes the same options. The vulnerability data comes from your audit sources (nuget.org's data is based on the GitHub Advisory Database), so a brand-new advisory may take time to show up. If the tool reports nothing for this CVE, still check the version with dotnet nuget why against what Microsoft published.
Fix it, closest to your direct reference first
NuGet's own guidance is to prefer updating the package closest to your direct references. If the package that pulled in System.Formats.Cbor has a newer version that depends on a fixed release, update that. If it does not, pin the fixed version yourself.
On the .NET 10 SDK and later, there is a command that updates vulnerable packages to the first version without known vulnerabilities:
dotnet package update --vulnerable
Review the diff it produces like any other change. If you use Central Package Management, transitive pinning is the cleanest way to force a fixed version of a package you do not reference directly. Here is a Directory.Packages.props for a solution on the .NET 9 line, using the fixed version the announcement names:
<Project>
<PropertyGroup>
<ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
<CentralPackageTransitivePinningEnabled>true</CentralPackageTransitivePinningEnabled>
</PropertyGroup>
<ItemGroup>
<!-- CVE-2026-118747: fixed in 9.0.24 for the .NET 9 package line -->
<PackageVersion Include="System.Formats.Cbor" Version="9.0.24" />
</ItemGroup>
</Project>
The announcement only names the .NET 9 package version. For the 8, 10, and 11 lines, take the fixed version from the MSRC advisory or the release notes rather than guessing. Without Central Package Management, the equivalent is a direct PackageReference to the fixed version in the affected project. Either way, leave a comment with the CVE number, and remove the pin once the package that pulled it in ships a fixed dependency of its own. Pins without a reason attached tend to live forever.
Then rebuild and redeploy. A package fix only exists in production after the new build is in production.
Layer 3: Code a Template Wrote for You
This is the layer I worry about most, because it has no version number. If your app uses ASP.NET Core Identity and you scaffolded its pages or components, that code is now yours. It sits in your repository like any other source file, and no runtime or package update will ever change it.
I am deliberately not going to describe what changed in the templates. The announcement does not say, and you should read the MSRC entry for CVE-2026-118741 for the specifics. What I can give you is a reliable way to find the code that needs attention and see what a patched template produces.
Find the generated code
Scaffolded Identity UI for Razor Pages and MVC typically lives under Areas/Identity. A Blazor Web App created with individual accounts puts its Identity components under Components/Account. A quick search across your repositories:
git ls-files | grep -E "(^|/)Areas/Identity/|(^|/)Components/Account/"
Any hits are candidates. Note that teams move and rename these folders, so also search for the Identity types your code uses, such as SignInManager and UserManager, to catch anything that was relocated.
Compare against a freshly generated template
Once your SDK is updated, generate a throwaway project with the same template and compare it to what you have. For a Blazor Web App:
# Using the updated SDK
dotnet new blazor --auth Individual -o /tmp/identity-reference
# Compare the generated account components with yours
git diff --no-index /tmp/identity-reference/Components/Account ./MyApp/Components/Account
Expect a noisy diff, because your project has evolved and the template has too. Most of the differences will be your own customizations, and that is fine. You are looking for the changes the advisory describes, then applying the same correction to your copy. Pin the SDK version you used in global.json so the next person can reproduce the comparison.
This is also a good moment to write down every place in your portfolio where generated code lives. Identity is the example this month. It will not be the last template-generated code to need a fix.
Make It a Gate, Not a Memory
Everything above is a manual check, and manual checks rely on someone remembering. NuGet Audit runs during every restore and already raises warnings NU1901 through NU1904 for low, moderate, high, and critical vulnerabilities. Two settings make it more useful.
First, audit transitive packages everywhere. Projects targeting .NET 10 or later default to NuGetAuditMode all, but .NET 8 and .NET 9 projects still default to direct, which would miss a transitive package like this one. Put this in Directory.Build.props at the root of the repository:
<Project>
<PropertyGroup>
<NuGetAudit>true</NuGetAudit>
<NuGetAuditMode>all</NuGetAuditMode>
<NuGetAuditLevel>low</NuGetAuditLevel>
<!-- Fail only in the audit pipeline; stay a warning everywhere else -->
<NuGetAuditCodes>NU1900;NU1901;NU1902;NU1903;NU1904;NU1905</NuGetAuditCodes>
<WarningsAsErrors Condition=" '$(AuditPipeline)' == 'true' ">$(WarningsAsErrors);$(NuGetAuditCodes)</WarningsAsErrors>
<WarningsNotAsErrors Condition=" '$(AuditPipeline)' != 'true' ">$(WarningsNotAsErrors);$(NuGetAuditCodes)</WarningsNotAsErrors>
</PropertyGroup>
</Project>
Second, run a dedicated audit job on a schedule. That conditional pattern comes from NuGet's own documentation, and I like it because a new advisory published on a Tuesday does not block an unrelated bug fix on Wednesday, but it does turn a scheduled pipeline red. Here is a GitHub Actions version that runs every Monday and keeps the full report as an artifact:
name: dependency-audit
on:
schedule:
- cron: "0 13 * * 1" # Mondays, 13:00 UTC
workflow_dispatch:
jobs:
audit:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-dotnet@v4
with:
dotnet-version: 10.0.x
- name: Restore with NuGet Audit as errors
run: dotnet restore MySolution.sln -p:AuditPipeline=true
- name: Vulnerable package report
if: always()
run: dotnet package list --project MySolution.sln --include-transitive --vulnerable --format json > vulnerable-packages.json
- name: Keep the report
if: always()
uses: actions/upload-artifact@v4
with:
name: vulnerable-packages
path: vulnerable-packages.json
Adjust the solution name, the SDK version, and the schedule to match your repository. The job will not catch Layer 3, since generated code has no package version to audit. That is why the inventory of template-generated code belongs in your patch checklist, right next to the runtime.
The Conversation for Leaders
If you lead a team or advise one as a fractional CTO, here is the question I would bring to this week's meeting: "When we say an app is patched, which layers do we mean?" If the honest answer is "the runtime," that is useful to know. It means the package and generated-code layers have no owner yet, and this month they had real fixes in them.
Assign an owner for each layer, not just each app. The infrastructure team can own runtime updates. Package and generated-code updates have to go through a build, a review, and a deployment, so they belong with the development team.
Your Next Step
Run dotnet nuget why for System.Formats.Cbor and the git ls-files search above against your most important solution today. Ten minutes will tell you whether either of this month's "runtime is not enough" fixes applies to you, and the Monday audit job will make sure you hear about the next one before your users do.
Categories