Stille risikoer i standard systemtekst JSON-serialisering
System.Text.Json-biblioteket har blitt standarden for de fleste moderne .NET-applikasjoner. Det er effektivt, lett og dypt integrert i ASP.NET Core. Men de samme standardinnstillingene som gjør det enkelt, introduserer også stille sikkerhetsrisikoer. Som standard serialiserer System.Text.Json-serialisering automatisk alle offentlige egenskaper, selv de som inneholder sensitive data som tokener eller interne identifikatorer. Utviklere er ofte avhengige av disse standardverdiene for hastighet, og overser at de kan eksponere konfidensiell informasjon i API-svar (jsonserializer).
⚠️Usikkert eksempel, kun for pedagogiske formål. Ikke bruk i produksjon.
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..."}
Denne jsonserializer-oppførselen eksponerer Sesjonstoken fordi alle offentlige egenskaper serialiseres automatisk.
Sikker versjon:
public class UserProfile
{
public string UserName { get; set; }
public string Email { get; set; }
[JsonIgnore] // Prevent serialization of sensitive fields
public string SessionToken { get; set; }
}
Pedagogisk merknad: Bruk alltid [JsonIgnore] for sensitive egenskaper eller design separate DTO-er som kun inneholder felt beregnet for serialisering.
Hvordan JsonSerializer utvider eksponering uten forvarsel
JsonSerializer i System.Text.Json stopper ikke på overflatenivå. Den går rekursivt gjennom nestede objekter, samlinger og enum-verdier, og serialiserer alt den kan få tilgang til. Uten eksplisitt utelukkelse kan dette lett føre til nestede datalekkasjer, spesielt når interne objekter inneholder tokener, identifikatorer eller øktnøkler.
⚠️Usikkert eksempel, kun for pedagogiske formål. Ikke bruk i produksjon.
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"}}
Det nestede objektet gjør at systemtekst-json-serialisering inkluderer den sensitive Tilgangstoken automatisk.
Sikker versjon:
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);
Pedagogisk merknad: Definer alltid JsonSerializerOptions eksplisitt og gjennomgå nestede typer for utilsiktet dataeksponering.
Virkelig innvirkning i API-er og mikrotjenester
I virkelige .NET-applikasjoner går disse serialiseringsrisikoene ofte ubemerket hen før etter utrulling. Kombinasjonen av automatisering, gjenbruk av DTO og standard jsonserializer-oppførsel forsterker eksponeringen. Vanlige mønstre der usikker serialisering lekker data:
- Gjenbruk av EF Core-enheter direkte i API-svar.
Logging av serialiserte objekter som inneholder autentiseringsdata. - Deling av modeller mellom interne og offentlige tjenester i CI/CD pipelines.
⚠️Usikkert eksempel, kun for pedagogiske formål. Ikke bruk i produksjon.
// Logs the full object, including sensitive fields
_logger.LogInformation("Response: {data}", JsonSerializer.Serialize(result));
Dersom resultere inneholder PassordHash or Sesjonstoken, disse er nå lagret i CI/CD logger, brudd prinsippene om minst privilegier. Aldri eksponer ekte tokener, legitimasjon eller interne URL-er i pipelines.
Sikker versjon:
var options = new JsonSerializerOptions
{
IgnoreReadOnlyProperties = true,
DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
};
// Sanitize before serialization
result.SessionToken = null;
_logger.LogInformation("Response: {data}", JsonSerializer.Serialize(result, options));
Pedagogisk merknad: Rens eller nullstill sensitive felt før logging, og bruk alltid sikker JsonSerializerOptions standardinnstillinger for revisjonsutdata.
Sikker serialiseringspraksis for utviklere
Utviklere bør behandle standardverdiene for system.text.json som et bekvemmelighetslag, ikke en sikkerhetspolicy. Sikker JSON-serialisering av systemtekst betyr å ta kontroll over hva som forlater applikasjonen din.
Praktisk forsvar
- Definer eksplisitte kontrakter: Opprett dedikerte DTO-er for API-svar, serialiser aldri EF- eller domeneenheter direkte.
- Konfigurer globale alternativer: Bruk JsonSerializerOptions.DefaultIgnoreCondition og Eiendomsnavnepolicy.
- Påfør [JsonIgnore] eller omformere: Skjul eller transformer sensitive data.
- Valider utdata: Inspiser faktiske serialiserte svar i tester.
- Automatiser sjekker: Inkluder serialiseringsvalidering i CI/CD.
Mini forebyggende sjekkliste
- Gjennomgå alle klasser ved hjelp av System.Text.Json-serialisering
- Merk hemmeligheter eller legitimasjon med [JsonIgnore]
- Definer globale sikre standardinnstillinger i Program.cs or Startup.cs
- Unngå direkte serialisering i logger
- Inkluder serialiseringseksponeringstester i din CI/CD pipeline
Pedagogisk merknad: Sikker serialisering handler om å begrense eksponering, ikke å øke kompleksiteten. Gjør serialisering eksplisitt og testbar.
Oppdage usikker serialisering med automatisert skanning – System.Text.Json
Automatisert skanning i CI/CD hjelper med å oppdage risikabel bruk av System.Text.Json og JsonSerializer. Statiske analyseverktøy kan identifisere:
- Modeller mangler [JsonIgnore].
- Sensitive felt eksponert i DTO-er.
- Usikre globale standardinnstillinger (f.eks. mangel på ignoreringsbetingelser).
Eksempel Pipeline Trykk her
# Never expose real tokens, credentials, or internal URLs in pipelines
- name: Run serialization security checks
run: dotnet xygeni validate --rules serialization --fail-on-risk
Pedagogisk merknad: Integrering statiske sjekker inn i din CI/CD sikrer konsekvent kontroll over JSON-serialisering av systemtekst på tvers av alle bygg.
Hvordan Xygeni Code Security Styrker .NET-serialiseringssikkerheten
Xygeni Code Security gir dyp deteksjon for usikre System.Text.Json-standarder og misbruk av JsonSerializer i NET.
Den identifiserer mønstre som:
- Sensitive felt serialiseres som standard.
- Usikker logging av JSON-data.
- Manglende [JsonIgnore] egenskaper.
- Feilkonfigurerte JSON-serialiseringsalternativer for systemtekst.
Ved å integrere Xygeni inn pre-commit hooks, CI/CD pipelines, eller PR-porter, kan du blokkere sårbare serialiseringsmønstre før de slås sammen. Den utfyller din eksisterende DevSecOps-prosess ved å gjøre feilkonfigurasjoner i serialisering om til håndhevbare sikkerhetspolicyer.
Opplæringsmerknad: Sikkerhetsverktøy som Xygeni håndhever serialiseringshygiene automatisk, frigjør utviklere til å fokusere på kode, ikke revisjoner.
Konklusjon – Om System.Text.Json
System.Text.Json gjør serialisering rask, men bekvemmelighet skjuler ofte eksponering. Standard system.text.json-serialisering inkluderer alle offentlige egenskaper, som potensielt kan lekke interne data, tokener eller identifikatorer.
Utviklere bør:
- Revider modellene deres.
- Bruk [JsonIgnore] og trygt JsonSerializerOptions.
- Unngå å serialisere interne objekter.
- Automatiser skanning ved hjelp av verktøy som Xygeni Code Security.
Standardserialisering er ikke bare en snarvei for utviklere; det er en potensiell datalekkasje. Gjør serialisering eksplisitt, bekreft utdata og automatiser kontroller, fordi sikre standardinnstillinger ikke alltid er trygge.
