Stille risico's in standaard systeemtekst JSON-serialisatie
De System.Text.Json-bibliotheek is de standaard geworden voor de meeste moderne .NET-applicaties. Het is efficiënt, lichtgewicht en diep geïntegreerd in ASP.NET Core. Maar dezelfde standaardinstellingen die het eenvoudig maken, brengen ook stille beveiligingsrisico's met zich mee. Standaard serialiseert System.Text.Json automatisch alle openbare eigenschappen, zelfs die met gevoelige gegevens zoals tokens of interne identificatiegegevens. Ontwikkelaars vertrouwen vaak op deze standaardinstellingen voor snelheid, waarbij ze over het hoofd zien dat ze vertrouwelijke informatie in API-reacties kunnen blootstellen (jsonserializer).
⚠️Onveilig voorbeeld, alleen voor educatieve doeleinden. Niet gebruiken in productie.
public class UserProfile { public string UserName { get; set; } public string Email { get; set; } public string SessionToken { get; set; } // Sensitive field } var json = JsonSerializer.Serialize(userProfile); Console.WriteLine(json); // Output: {"UserName":"alex","Email":"alex@example.com","SessionToken":"eyJhbGciOi..."} Dit jsonserializer-gedrag legt bloot SessieToken omdat alle openbare eigenschappen automatisch worden geserialiseerd.
Veilige versie:
public class UserProfile { public string UserName { get; set; } public string Email { get; set; } [JsonIgnore] // Prevent serialization of sensitive fields public string SessionToken { get; set; } } Educatieve opmerking: Gebruik altijd [Json Negeren] voor gevoelige eigenschappen of ontwerp aparte DTO's die alleen velden bevatten die bedoeld zijn voor serialisatie.
Hoe JsonSerializer de blootstelling zonder waarschuwing uitbreidt
De JsonSerializer in System.Text.Json stopt niet op het oppervlak. Hij doorloopt recursief geneste objecten, verzamelingen en enumwaarden en serialiseert alles waartoe hij toegang heeft. Zonder expliciete uitsluiting kan dit gemakkelijk leiden tot geneste datalekken, vooral wanneer interne objecten tokens, identificatiegegevens of sessiesleutels bevatten.
⚠️Onveilig voorbeeld, alleen voor educatieve doeleinden. Niet gebruiken in productie.
public class AuthData { public string AccessToken { get; set; } // Sensitive } public class ApiResponse { public string Message { get; set; } public AuthData AuthInfo { get; set; } // Nested object } var json = JsonSerializer.Serialize(new ApiResponse { Message = "OK", AuthInfo = new AuthData { AccessToken = "abc123" } }); Console.WriteLine(json); // Output: {"Message":"OK","AuthInfo":{"AccessToken":"abc123"}} Het geneste object zorgt ervoor dat de systeemtekst-json-serialisatie de gevoelige informatie bevat Toegangstoken automatisch.
Veilige versie:
public class AuthData { [JsonIgnore] // Prevent exposure of sensitive tokens public string AccessToken { get; set; } } public class ApiResponse { public string Message { get; set; } public AuthData AuthInfo { get; set; } } var options = new JsonSerializerOptions { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault, WriteIndented = false }; var json = JsonSerializer.Serialize(apiResponse, options); Educatieve opmerking: Altijd definiëren JsonSerializerOptions expliciet en controleer geneste typen op onbedoelde blootstelling van gegevens.
Impact in de praktijk op API's en microservices
In echte .NET-applicaties blijven deze serialisatierisico's vaak onopgemerkt tot na de implementatie. De combinatie van automatisering, hergebruik van DTO's en standaard jsonserializer-gedrag vergroot de kwetsbaarheid. Veelvoorkomende patronen waarbij onveilige serialisatie gegevens laat lekken:
- EF Core-entiteiten rechtstreeks hergebruiken in API-reacties.
Het loggen van geserialiseerde objecten die authenticatiegegevens bevatten. - Het delen van modellen tussen interne en publieke diensten in CI/CD pipelines.
⚠️Onveilig voorbeeld, alleen voor educatieve doeleinden. Niet gebruiken in productie.
// Logs the full object, including sensitive fields _logger.LogInformation("Response: {data}", JsonSerializer.Serialize(result)); Indien de resultaat bevat Wachtwoordhash or SessieToken, deze worden nu opgeslagen in CI/CD logs, in strijd met principes van de minste privileges. Stel nooit echte tokens, inloggegevens of interne URL's bloot in pipelines.
Veilige versie:
var options = new JsonSerializerOptions { IgnoreReadOnlyProperties = true, DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull }; // Sanitize before serialization result.SessionToken = null; _logger.LogInformation("Response: {data}", JsonSerializer.Serialize(result, options)); Educatieve opmerking: Maak gevoelige velden schoon of vernietig ze voordat u gaat loggen en gebruik altijd veilige JsonSerializerOptions standaardinstellingen voor audituitvoer.
Veilige serialisatiepraktijken voor ontwikkelaars
Ontwikkelaars moeten de standaardinstellingen van system.text.json beschouwen als een handige laag, niet als een beveiligingsbeleid. Veilige serialisatie van systeemtekst in JSON betekent dat u zelf de controle heeft over wat uw applicatie verlaat.
Praktische verdedigingen
- Definieer expliciete contracten: Maak speciale DTO's voor API-reacties en serialiseer EF- of domeinentiteiten nooit rechtstreeks.
- Globale opties configureren: Gebruik JsonSerializerOptions.DefaultIgnoreCondition en Eigenschapsnaamgevingsbeleid.
- Toepassen [Json Negeren] of converters: Gevoelige gegevens verbergen of transformeren.
- Valideer uitvoer: Inspecteer daadwerkelijke geserialiseerde reacties in tests.
- Automatische controles: Inclusief serialisatievalidatie in CI/CD.
Mini Preventieve Checklist
- Bekijk alle klassen die gebruikmaken van System.Text.Json-serialisatie
- Markeer geheimen of referenties met [Json Negeren]
- Definieer wereldwijde veilige standaardinstellingen in Programma.cs or Startup.cs
- Vermijd directe serialisatie in logs
- Neem serialisatie-blootstellingstests op in uw CI/CD pipeline
Educatieve opmerking: Veilige serialisatie gaat over het beperken van de blootstelling, niet over het toevoegen van complexiteit. Maak serialisatie expliciet en testbaar.
Detectie van onveilige serialisatie met geautomatiseerd scannen – System.Text.Json
Geautomatiseerd scannen in CI/CD Helpt bij het detecteren van riskant gebruik van System.Text.Json en JsonSerializer. Statische analysetools kunnen het volgende identificeren:
- Modellen ontbreken [Json Negeren].
- Gevoelige velden blootgesteld in DTO's.
- Onveilige globale standaardinstellingen (bijvoorbeeld gebrek aan negeervoorwaarden).
Voorbeeld Pipeline Check
# Never expose real tokens, credentials, or internal URLs in pipelines - name: Run serialization security checks run: dotnet xygeni validate --rules serialization --fail-on-risk Educatieve opmerking: Integreren statische controles in uw CI/CD zorgt voor consistente controle over de JSON-serialisatie van systeemtekst in alle builds.
Hoe Xygeni Code Security Versterkt de .NET-serialisatiebeveiliging
Xygeni Code Security biedt diepgaande detectie van onveilige System.Text.Json-standaardinstellingen en misbruik van JsonSerializer in NET.
Het identificeert patronen zoals:
- Gevoelige velden worden standaard geserialiseerd.
- Onveilige logging van JSON-gegevens.
- Vermist [Json Negeren] attributen.
- Verkeerd geconfigureerde JSON-serialisatieopties voor systeemtekst.
Door de integratie Xygeni om in pre-commit hooks, CI/CD pipelineMet s, of PR-poorten, kunt u kwetsbare serialisatiepatronen blokkeren voordat ze worden samengevoegd. Het vormt een aanvulling op uw bestaande DevSecOps-proces door serialisatiefouten om te zetten in afdwingbare beveiligingsbeleidsregels.
Onderwijsnotitie: Beveiligingstools zoals Xygeni zorgen automatisch voor serialisatiehygiëne, Hierdoor kunnen ontwikkelaars zich concentreren op de code en niet op audits.
Conclusie – Over Systeem.Tekst.Json
Systeem.Tekst.Json Maakt serialisatie snel, maar gemak verhult vaak kwetsbaarheid. Standaard system.text.json-serialisatie omvat elke openbare eigenschap, waardoor interne gegevens, tokens of identifiers mogelijk kunnen lekken.
Ontwikkelaars moeten:
- Controleer hun modellen.
- Gebruik [Json Negeren] en veilig JsonSerializerOptions.
- Vermijd het serialiseren van interne objecten.
- Automatiseer het scannen met behulp van hulpmiddelen zoals Xygeni Code Security.
Standaard serialisatie is niet zomaar een trucje voor ontwikkelaars; het is een potentieel datalek. Maak serialisatie expliciet, verifieer uitvoer en automatiseer controles, want veilige standaardinstellingen zijn niet altijd veilig.
