Self-defending JavaScript and checksums fail once the attacker can patch the checker
A popular last line of defense in client JavaScript is an integrity check. The script hashes its own...
Tag archive
A popular last line of defense in client JavaScript is an integrity check. The script hashes its own...
Many teams start obfuscating or VM-protecting client JavaScript in the production Vite or webpack...
Orleans routes every grain call by strings in the cluster manifest — a GrainInterfaceType and a GrainType derived by default from your .NET type names. Rename a grain and the identity moves, orphaning persisted state and breaking cross-silo calls. Here is how to decouple identity with [Alias]/[GrainType] and still obfuscate aggressively.
Polymorphic serialization puts type identity on the wire. Newtonsoft TypeNameHandling embeds the CLR type name, which obfuscation renames — breaking every persisted document. System.Text.Json [JsonDerivedType] uses a string discriminator decoupled from the type, so it renames freely. Here is exactly why, and how to obfuscate the hierarchy safely.
A Next.js or Nuxt app can feel like the business logic already lives on the server. You have Server...
Most teams that add JavaScript protection start in the wrong place: they run an obfuscator over the...
MassTransit derives a message''s identity — its MessageUrn, like urn:message:Contoso.Ordering.Contracts:OrderSubmitted — from the contract type''s .NET namespace and name, then uses it to name the broker exchange or topic and stamps it into the envelope''s messageType header. Producer and consumers, often deployed separately, must agree on it. Obfuscate after the build and renaming the contract type or namespace changes the URN, so the producer publishes to a different exchange and stamps a different messageType, and existing consumers silently stop receiving. This post explains exactly how the URN is built from the type, why the message contract assembly is the fragile surface, and how to pin the contract namespaces, names and properties with a Nebula.NET keep-list while renaming consumers, sagas and internals.
Dapper matches result-set column names to your POCO''s public members by name, case-insensitively, at materialization time. Rename those members with an obfuscator and Dapper silently stops matching — no exception, just a property left at null or 0. This is the full picture: exactly how Dapper''s default type handler binds a column to a member, why your SQL text is usually safe but your POCO members are fragile, the custom-map escape hatches, and the precise nebula.config.json keep-list that pins the query-result POCOs while renaming the rest of the data layer.
Hangfire serializes every enqueued, scheduled and recurring job to storage as the fully-qualified type name, method name and parameter types, then resolves that back to a MethodInfo by reflection when a worker runs it — possibly on a later deployment. Obfuscate after the build and renaming moves the job class or method out from under those stored strings, so every in-flight and recurring job fails to deserialize with a could-not-load-type error. This post explains exactly what Hangfire writes to its storage, why recurring and long-delayed jobs are the sharpest edge, and how to pin the job classes, invoked methods and their parameter types with a Nebula.NET keep-list while renaming everything else.
The configuration binder maps appsettings.json and environment-variable keys to the public property names of your options POCO by reflection. Rename those properties in an obfuscation pass and the bound values silently become null or default at runtime — no compile error, no exception, just wrong behavior. This post reads exactly how `services.Configure<T>` resolves keys to property setters, what the .NET 8+ source-generated binder changes and what it does not, how to build a nebula.config.json keep-list that pins the public property names and the parameterless constructor of your options classes while renaming everything else, and how to confirm in Glass.NET that the options surface survived.
AWS Lambda''s managed .NET runtime finds your code through a handler string of the form Assembly::Namespace.Type::Method, which it resolves by reflection at every cold start. Obfuscate after the build and renaming moves the handler type or method out from under that string — the assembly is valid, but Lambda fails to resolve the entry point and the invocation errors before your code runs. This post explains where the handler string lives, which symbols the managed runtime and the Lambda serializer resolve by name, how to pin exactly those with a Nebula.NET keep-list while renaming everything else, and how to fold nebula protect into dotnet lambda package.
SignalR dispatches every real-time message by matching a string to a method. A client calls `connection.InvokeAsync("SendMessage", ...)` and registers `hubConnection.On("ReceiveMessage", ...)`, and the server resolves those strings to hub methods by name at runtime. Rename a public hub method or a strongly-typed client interface member and the dispatch silently fails — the connection stays up, but the message never lands. This post reads how SignalR''s dispatcher maps the invocation target string to your hub method, why `[HubMethodName]` and `Hub<T>` change which names are load-bearing, how to build a nebula.config.json keep-list that pins exactly the wire-visible method surface while renaming hub bodies, internal services and DTO internals, and how to confirm in Glass.NET that only the intended names survived.