Stille Risiken bei der standardmäßigen systemweiten Text-JSON-Serialisierung
Die Bibliothek System.Text.Json ist in den meisten modernen .NET-Anwendungen zum Standard geworden. Sie ist effizient, ressourcenschonend und tief in ASP.NET Core integriert. Doch genau diese Standardeinstellungen, die die Verwendung so einfach machen, bergen auch versteckte Sicherheitsrisiken. Standardmäßig serialisiert die Serialisierung von System.Text.Json automatisch alle öffentlichen Eigenschaften, auch solche, die sensible Daten wie Token oder interne Kennungen enthalten. Entwickler verlassen sich aus Geschwindigkeitsgründen oft auf diese Standardeinstellungen und übersehen dabei, dass dadurch vertrauliche Informationen in API-Antworten offengelegt werden könnten (jsonserializer).
⚠️Unsicheres Beispiel, nur zu Schulungszwecken. Nicht in der Produktion verwenden.
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..."}
Dieses Verhalten des JSON-Serialisierers legt Folgendes offen: SessionToken weil alle öffentlichen Eigenschaften automatisch serialisiert werden.
Sichere Version:
public class UserProfile
{
public string UserName { get; set; }
public string Email { get; set; }
[JsonIgnore] // Prevent serialization of sensitive fields
public string SessionToken { get; set; }
}
Pädagogischer Hinweis: Verwenden Sie immer [JsonIgnore] für sensible Eigenschaften oder separate DTOs entwerfen, die nur Felder enthalten, die für die Serialisierung bestimmt sind.
Wie JsonSerializer die Datensicherheit ohne Vorwarnung erhöht
Der JsonSerializer in System.Text.Json beschränkt sich nicht auf die oberste Ebene. Er durchläuft rekursiv verschachtelte Objekte, Sammlungen und Enum-Werte und serialisiert alles, worauf er zugreifen kann. Ohne expliziten Ausschluss kann dies leicht zu verschachtelten Datenlecks führen, insbesondere wenn interne Objekte Token, Kennungen oder Sitzungsschlüssel enthalten.
⚠️Unsicheres Beispiel, nur zu Schulungszwecken. Nicht in der Produktion verwenden.
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"}}
Das verschachtelte Objekt bewirkt, dass die JSON-Serialisierung von Systemtext sensible Daten einschließt. Zugangstoken automatisch.
Sichere Version:
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);
Pädagogischer Hinweis: Immer definieren JsonSerializerOptions explizit und überprüfen Sie verschachtelte Datentypen auf unbeabsichtigte Datenoffenlegung.
Auswirkungen in der Praxis bei APIs und Microservices
In realen .NET-Anwendungen bleiben diese Serialisierungsrisiken oft erst nach der Bereitstellung bemerkt. Die Kombination aus Automatisierung, DTO-Wiederverwendung und dem Standardverhalten des JSON-Serialisierers verstärkt dieses Risiko. Häufige Muster, bei denen unsichere Serialisierung zu Datenlecks führt:
- EF Core-Entitäten direkt in API-Antworten wiederverwenden.
Protokollierung serialisierter Objekte, die Authentifizierungsdaten enthalten. - Sharing-Modelle zwischen internen und öffentlichen Diensten in CI/CD pipelines.
⚠️Unsicheres Beispiel, nur zu Schulungszwecken. Nicht in der Produktion verwenden.
// Logs the full object, including sensitive fields
_logger.LogInformation("Response: {data}", JsonSerializer.Serialize(result));
Besitzt das Folge enthält Passwort-Hash or SessionTokenDiese werden nun gespeichert in CI/CD Protokolle, die gegen die Regeln verstoßen Grundsatz der minimalen Privilegien. Geben Sie niemals echte Token, Anmeldeinformationen oder interne URLs preis in pipelines.
Sichere Version:
var options = new JsonSerializerOptions
{
IgnoreReadOnlyProperties = true,
DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
};
// Sanitize before serialization
result.SessionToken = null;
_logger.LogInformation("Response: {data}", JsonSerializer.Serialize(result, options));
Pädagogischer Hinweis: Sensible Felder vor dem Protokollieren bereinigen oder löschen und stets sichere Protokollierungsmethoden verwenden. JsonSerializerOptions Standardeinstellungen für die Audit-Ausgabe.
Sichere Serialisierungspraktiken für Entwickler
Entwickler sollten die Standardeinstellungen von `system.text.json` als Komfortfunktion und nicht als Sicherheitsrichtlinie betrachten. Sichere JSON-Serialisierung von System.text bedeutet, die Kontrolle darüber zu behalten, welche Daten die Anwendung verlassen.
Praktische Verteidigungsstrategien
- Explizite Verträge definieren: Erstellen Sie dedizierte DTOs für API-Antworten, serialisieren Sie EF- oder Domänenentitäten niemals direkt.
- Globale Optionen konfigurieren: Arbeiten jederzeit weiterbearbeiten können. Jede Präsentation und jeder KI-Avatar, den Sie von Grund auf neu erstellen oder hochladen, JsonSerializerOptions.DefaultIgnoreCondition und Richtlinie zur Immobilienbenennung.
- Tragen Sie [JsonIgnore] oder Konverter: Sensible Daten ausblenden oder transformieren.
- Ausgaben validieren: Überprüfen Sie die tatsächlichen serialisierten Antworten in Tests.
- Automatisieren Sie Prüfungen: Fügen Sie die Serialisierungsvalidierung hinzu in CI/CD.
Mini-Checkliste zur Prävention
- Überprüfen Sie alle Klassen, die die Serialisierung System.Text.Json verwenden.
- Kennzeichnen Sie Geheimnisse oder Zugangsdaten mit [JsonIgnore]
- Globale sichere Standardwerte definieren in Programm.cs or Startup.cs
- Vermeiden Sie die direkte Serialisierung in Protokollen.
- Führen Sie Serialisierungs-Expositionstests in Ihrem CI/CD pipeline
Pädagogischer Hinweis: Sichere Serialisierung bedeutet, die Angriffsfläche zu minimieren, nicht die Komplexität zu erhöhen. Gestalten Sie die Serialisierung explizit und testbar.
Erkennung unsicherer Serialisierung durch automatisiertes Scannen – System.Text.Json
Automatisiertes Scannen in CI/CD Hilft dabei, riskante Verwendung von System.Text.Json und JsonSerializer zu erkennen. Statische Analysetools können Folgendes identifizieren:
- Fehlende Modelle [JsonIgnore].
- In DTOs sind empfindliche Felder freigelegt.
- Unsichere globale Standardeinstellungen (z. B. fehlende Ignorierbedingungen).
Beispiel Pipeline Einblick in das
# Never expose real tokens, credentials, or internal URLs in pipelines
- name: Run serialization security checks
run: dotnet xygeni validate --rules serialization --fail-on-risk
Pädagogischer Hinweis: Integration statische Prüfungen für Ihre CI/CD gewährleistet eine konsistente Kontrolle über die JSON-Serialisierung von Systemtexten über alle Builds hinweg.
Wie Xygeni Code Security Stärkt die Serialisierungssicherheit von .NET
Xygeni Code Security Bietet eine gründliche Erkennung unsicherer System.Text.Json-Standardeinstellungen und des Missbrauchs von JsonSerializer in .NET.
Es erkennt Muster wie:
- Sensible Felder werden standardmäßig serialisiert.
- Unsichere Protokollierung von JSON-Daten.
- Vermisst [JsonIgnore] Attribute.
- Falsch konfigurierte Optionen für die JSON-Serialisierung von Systemtexten.
Durch die Integration Xygeni in pre-commit hooks, CI/CD pipelineMit PR-Gates können Sie anfällige Serialisierungsmuster blockieren, bevor sie zusammengeführt werden. Es ergänzt Ihren bestehenden DevSecOps-Prozess, indem es Fehlkonfigurationen der Serialisierung in durchsetzbare Sicherheitsrichtlinien umwandelt.
Hinweis für den Bildungsbereich: Sicherheitstools wie Xygeni erzwingen die Serialisierungshygiene automatisch. Dadurch können sich die Entwickler auf den Code konzentrieren, anstatt auf Audits.
Fazit – Über System.Text.Json
System.Text.Json Die Serialisierung wird dadurch zwar beschleunigt, doch der Komfort birgt oft Risiken. Die standardmäßige Serialisierung von system.text.json schließt alle öffentlichen Eigenschaften ein und kann so potenziell interne Daten, Token oder Kennungen offenlegen.
Entwickler sollten:
- Überprüfen Sie ihre Modelle.
- Arbeiten jederzeit weiterbearbeiten können. Jede Präsentation und jeder KI-Avatar, den Sie von Grund auf neu erstellen oder hochladen, [JsonIgnore] und sicher JsonSerializerOptions.
- Vermeiden Sie die Serialisierung interner Objekte.
- Automatisieren Sie das Scannen mithilfe von Tools wie Xygeni Code Security.
Die standardmäßige Serialisierung ist nicht nur eine praktische Entwicklerlösung, sondern birgt auch ein potenzielles Datenleck. Serialisierung sollte explizit festgelegt, Ausgaben überprüft und Prüfungen automatisiert werden, denn vermeintlich sichere Standardeinstellungen sind nicht immer sicher.
