Risques silencieux liés à la sérialisation JSON du texte système par défaut
La bibliothèque System.Text.Json est devenue la bibliothèque par défaut de la plupart des applications .NET modernes. Elle est efficace, légère et profondément intégrée à ASP.NET Core. Cependant, ces mêmes paramètres par défaut qui la rendent simple d'utilisation introduisent également des failles de sécurité insidieuses. Par défaut, la sérialisation de System.Text.Json sérialise automatiquement toutes les propriétés publiques, même celles contenant des données sensibles comme des jetons ou des identifiants internes. Les développeurs s'appuient souvent sur ces paramètres par défaut pour gagner en rapidité, sans se rendre compte qu'ils peuvent exposer des informations confidentielles dans les réponses d'API (jsonserializer).
⚠️Exemple non sécurisé, à des fins pédagogiques uniquement. Ne pas utiliser en production.
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..."}
Ce comportement de jsonserializer expose SessionToken car toutes les propriétés publiques sont sérialisées automatiquement.
Version sécurisée :
public class UserProfile
{
public string UserName { get; set; }
public string Email { get; set; }
[JsonIgnore] // Prevent serialization of sensitive fields
public string SessionToken { get; set; }
}
Note pédagogique : Toujours utiliser [JsonIgnore] pour les propriétés sensibles ou pour concevoir des DTO distincts qui ne contiennent que des champs destinés à la sérialisation.
Comment JsonSerializer accroît l'exposition sans avertissement
Le JsonSerializer de System.Text.Json ne se contente pas d'un traitement superficiel. Il parcourt récursivement les objets imbriqués, les collections et les valeurs d'énumération, sérialisant tout ce à quoi il peut accéder. Sans exclusion explicite, cela peut facilement entraîner des fuites de données imbriquées, notamment lorsque les objets internes contiennent des jetons, des identifiants ou des clés de session.
⚠️Exemple non sécurisé, à des fins pédagogiques uniquement. Ne pas utiliser en production.
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"}}
L'objet imbriqué permet à la sérialisation JSON du texte système d'inclure les données sensibles. Jeton d'accès automatiquement.
Version sécurisée :
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);
Note pédagogique : Toujours définir Options du sérialiseur Json Examinez explicitement les types imbriqués afin d'éviter toute exposition de données non intentionnelle.
Impact concret des API et des microservices
Dans les applications .NET réelles, ces risques de sérialisation passent souvent inaperçus jusqu'au déploiement. L'automatisation, la réutilisation des DTO et le comportement par défaut du sérialiseur JSON amplifient leur exposition. Scénarios courants de fuites de données lors de la sérialisation non sécurisée :
- Réutilisation directe des entités EF Core dans les réponses API.
Enregistrement des objets sérialisés contenant des données d'authentification. - Modèles de partage entre services internes et publics dans CI/CD pipelines.
⚠️Exemple non sécurisé, à des fins pédagogiques uniquement. Ne pas utiliser en production.
// Logs the full object, including sensitive fields
_logger.LogInformation("Response: {data}", JsonSerializer.Serialize(result));
Si la résultat contient Hachage du mot de passe or SessionToken, ceux-ci sont maintenant stockés dans CI/CD bûches, en violation Principe du moindre privilège. Ne jamais exposer de véritables jetons, identifiants ou URL internes dans pipelines.
Version sécurisée :
var options = new JsonSerializerOptions
{
IgnoreReadOnlyProperties = true,
DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
};
// Sanitize before serialization
result.SessionToken = null;
_logger.LogInformation("Response: {data}", JsonSerializer.Serialize(result, options));
Note pédagogique : Nettoyez ou supprimez les champs sensibles avant la connexion et utilisez toujours des méthodes de chiffrement sécurisées. Options du sérialiseur Json Valeurs par défaut pour la sortie d'audit.
Bonnes pratiques de sérialisation pour les développeurs
Les développeurs doivent considérer les valeurs par défaut de system.text.json comme une simple commodité, et non comme une politique de sécurité. Une sérialisation JSON sécurisée du texte système implique de maîtriser les données qui quittent l'application.
Défenses pratiques
- Définir des contrats explicites : Créez des DTO dédiés aux réponses API, ne sérialisez jamais directement les entités EF ou de domaine.
- Configurer les options globales : Utilisez le JsonSerializerOptions.DefaultIgnoreCondition et Politique de dénomination des propriétés.
- Appliquer [JsonIgnore] ou convertisseurs : Masquer ou transformer les données sensibles.
- Valider les résultats : Examinez les réponses sérialisées réelles dans les tests.
- Automatiser les vérifications : Inclure la validation de la sérialisation dans CI/CD.
Mini liste de contrôle préventive
- Examinez toutes les classes utilisant la sérialisation System.Text.Json
- Marquer les secrets ou les identifiants avec [JsonIgnore]
- Définir des valeurs par défaut globales sécurisées dans programme.cs or Démarrage.cs
- Évitez la sérialisation directe dans les journaux.
- Incluez des tests d'exposition à la sérialisation dans votre CI/CD pipeline
Note pédagogique : La sérialisation sécurisée vise à limiter l'exposition, et non à complexifier le processus. Il est essentiel de rendre la sérialisation explicite et testable.
Détection de la sérialisation non sécurisée par analyse automatisée – System.Text.Json
Numérisation automatisée dans CI/CD permet de détecter les utilisations à risque de System.Text.Json et JsonSerializer. Les outils d'analyse statique peuvent identifier :
- Modèles manquants [JsonIgnore].
- Champs sensibles exposés dans les DTO.
- Valeurs par défaut globales non sécurisées (par exemple, absence de conditions à ignorer).
Exemple Pipeline Vérifiez
# Never expose real tokens, credentials, or internal URLs in pipelines
- name: Run serialization security checks
run: dotnet xygeni validate --rules serialization --fail-on-risk
Note pédagogique : Intégration vérifications statiques dans votre CI/CD assure un contrôle cohérent de la sérialisation JSON du texte système sur toutes les versions.
En quoi Xygeni Code Security Renforce la sécurité de la sérialisation .NET
Xygéni Code Security assure une détection approfondie des valeurs par défaut non sécurisées de System.Text.Json et de l'utilisation abusive de JsonSerializer dans .NET.
Il identifie des schémas tels que :
- Les champs sensibles sont sérialisés par défaut.
- Enregistrement non sécurisé des données JSON.
- Manquant [JsonIgnore] attributs.
- Options de sérialisation JSON du texte système mal configurées.
En intégrant Xygéni développement pre-commit hooks, CI/CD pipelineGrâce aux portes PR (ou portes PR), vous pouvez bloquer les modèles de sérialisation vulnérables avant leur fusion. Il complète votre processus DevSecOps existant en transformant les erreurs de configuration de sérialisation en politiques de sécurité applicables.
Note pédagogique : Les outils de sécurité comme Xygeni appliquent automatiquement les règles de sérialisation. Permettre aux développeurs de se concentrer sur le code, et non sur les audits.
Conclusion – À propos System.Text.Json
System.Text.Json Cela accélère la sérialisation, mais cette facilité d'utilisation masque souvent des risques. La sérialisation par défaut de system.text.json inclut toutes les propriétés publiques, ce qui peut entraîner la divulgation de données internes, de jetons ou d'identifiants.
Les développeurs devraient :
- Auditez leurs modèles.
- Utilisez le [JsonIgnore] et sécuritaire Options du sérialiseur Json.
- Évitez de sérialiser les objets internes.
- Automatisez la numérisation à l'aide d'outils comme Xygeni Code Security.
La sérialisation par défaut n'est pas qu'un raccourci pour les développeurs ; elle représente une source potentielle de fuites de données. Rendez la sérialisation explicite, vérifiez les résultats et automatisez les contrôles, car les valeurs par défaut, même si elles paraissent sûres, ne le sont pas toujours.
