fix(serialization)!: enforce type allow-list in default JSON storage serializer

[ReubenBond]

Problem

Orleans'' default grain-storage serializer (JsonGrainStorageSerializer → OrleansJsonSerializer) is configured with TypeNameHandling.All, so every serialized object embeds a $type token that is honored on read. The OrleansJsonSerializationBinder resolved that $type via CachedTypeResolver and, on failure, fell back to Newtonsoft''s permissive DefaultSerializationBinder — neither consults any allow-list. An attacker able to influence persisted, streamed, or transactional state could therefore cause arbitrary CLR types to be constructed during deserialization — the classic TypeNameHandling.All gadget-chain vulnerability. The same shared settings feed grain storage, JSON streaming, and (Azure) transactional state, so all three were affected.

Solution

Make the binder enforce Orleans'' existing type allow-list rather than introduce a parallel Newtonsoft-specific system. OrleansJsonSerializationBinder.BindToType now resolves $type through TypeConverter, which only constructs types that are permitted by the configured ITypeNameFilter / ITypeFilter / TypeManifestOptions.AllowedTypes (or auto-allow-listed via [GenerateSerializer]). Disallowed types throw an actionable JsonSerializationException that lists every remediation option.

This is secure by default with an opt-out:

• Well-behaved apps keep working unchanged: [GenerateSerializer] state types are already auto-allow-listed, and DefaultTypeFilter still permits BCL collections/primitives. TypeNameHandling.All is retained so existing persisted state stays readable — security comes from the binder, not from changing the wire format.
• A new, dedicated OrleansJsonSerializerOptions.AllowAllTypes (default false) restores the previous permissive behavior for the JSON storage/streaming/transaction path only, without weakening the native serializer''s global type filtering. Narrower opt-ins (AllowedTypes, ITypeNameFilter) are preferred and are surfaced in the exception message.
• The legacy OrleansJsonSerializationBinder(TypeResolver) constructor is kept (permissive) for API compatibility; a new constructor takes the TypeConverter + opt-out flag.

Compatibility

Breaking for apps that persist $type entries for types that are neither [GenerateSerializer]-registered nor covered by a filter — these now throw on read. The thrown exception explains the four ways to resolve it: mark the type [GenerateSerializer], add it to TypeManifestOptions.AllowedTypes, register an ITypeNameFilter/ITypeFilter, or set OrleansJsonSerializerOptions.AllowAllTypes = true to restore the old behavior.

Microsoft Reviewers: Open in CodeFlow

[azure-pipelines]

Azure Pipelines:
There may be pipelines that require an authorized user to comment /azp run to run.

[Copilot]

Pull request overview

This PR hardens Orleans’ default Newtonsoft.Json-based serializer path (grain storage/JSON streaming/transactional state) by enforcing the existing Orleans type allow-list when resolving $type values emitted under TypeNameHandling.All, mitigating gadget-chain deserialization risks while keeping the wire format compatible.

Changes:

• Update OrleansJsonSerializationBinder to resolve types through TypeConverter (allow-list enforcement), with an opt-out flag for legacy permissive behavior.
• Introduce OrleansJsonSerializerOptions.AllowAllTypes and plumb it through default JSON serializer settings configuration.
• Add targeted tests validating allow-listed vs disallowed type resolution and round-trip behavior, plus update API surface.

Show a summary per file

File	Description
test/Orleans.Core.Tests/Serialization/OrleansJsonSerializationBinderTests.cs	Adds coverage for strict vs permissive binder behavior during type binding and deserialization.
src/Orleans.Core/Serialization/OrleansJsonSerializerSettings.cs	Threads AllowAllTypes from options into binder creation for default JSON settings.
src/Orleans.Core/Serialization/OrleansJsonSerializerOptions.cs	Adds AllowAllTypes option and ensures settings are configured accordingly.
src/Orleans.Core/Serialization/OrleansJsonSerializationBinder.cs	Enforces Orleans type allow-list via TypeConverter, with legacy permissive compatibility path.
src/api/Orleans.Core/Orleans.Core.cs	Updates public API surface for new constructor and options property.

Copilot's findings

Suppressed comments (1)

test/Orleans.Core.Tests/Serialization/OrleansJsonSerializationBinderTests.cs:126

• This assertion uses Assert.ThrowsAny, which is overly broad and could pass for unrelated failures. Since deserialization of a disallowed $type is expected to fail with JsonSerializationException (thrown by the binder), assert that exception type explicitly.

        Assert.ThrowsAny<Exception>(() => JsonConvert.DeserializeObject(json, typeof(object), settings));

• Files reviewed: 5/5 changed files
• Comments generated: 2

[Copilot]

Copilot's findings

Suppressed comments (1)

src/Orleans.Core/Serialization/OrleansJsonSerializationBinder.cs:33

• The legacy constructor does not assign _typeConverter, but _typeConverter is a readonly field. This will not compile (readonly fields must be definitely assigned in every constructor).

        public OrleansJsonSerializationBinder(TypeResolver typeResolver)
        {
            _typeResolver = typeResolver;
            _allowAllTypes = true;
        }

• Files reviewed: 5/5 changed files
• Comments generated: 0 new