We intercepted a host quietly beaconing out of a locked-down network. The firewall logs every byte that leaves — and every byte here is boring. Same source, same destination, the same little
PINGpayload, over and over.And yet something is getting out. It’s buried in the noise, it’s scrambled, and the operator left just enough on the wire to unscramble it — if you know which columns to trust.
Find the message.
capture.pcapcsaw{t1m1ng_1s_3v3ryth1ng_1n_th3_s1l3nt_ch4nn3l}L’énoncé indique plusieurs éléments importants :
Avant même de commencer l’analyse, un premier problème apparaît : Wireshark refuse d’ouvrir le fichier fourni.
L’extension .pcap est pourtant correcte. Le problème se trouve dans les premiers octets du fichier, c’est-à-dire dans son magic number.
Un fichier PCAP little-endian classique commence par :
d4 c3 b2 a1
Or le fichier fourni commence par :
c4 c3 b2 a1
On remarque qu’un seul octet a été modifié :
c4 c3 b2 a1 <- fichier fourni
d4 c3 b2 a1 <- en-tête PCAP valide
^^
Cette modification suffit à empêcher Wireshark d’identifier correctement le fichier comme une capture PCAP.
Sous Kali Linux, on peut réparer directement l’en-tête avec dd.
On commence par afficher les quatre premiers octets :
xxd -l 10 capture.pcap
On obtient :
00000000: c4c3 b2a1 0200 0400 0000
Le premier octet est donc bien incorrect.
Afin de conserver le fichier original :
cp capture.pcap capture_fixed.pcap
Nous allons modifier uniquement capture_fixed.pcap.
ddLa commande suivante écrit la valeur hexadécimale d4 à l’offset 0 du fichier :
printf '\xd4' | dd of=capture_fixed.pcap bs=1 seek=0 count=1 conv=notrunc
Explication des options :
of=capture_fixed.pcap -> fichier à modifier
bs=1 -> travaille octet par octet
seek=0 -> écrit à partir du premier octet
count=1 -> écrit un seul octet
conv=notrunc -> ne tronque pas le reste du fichier
Il est particulièrement important d’utiliser :
conv=notrunc
Sans cette option, dd pourrait tronquer le fichier après l’octet écrit.
On contrôle de nouveau l’en-tête :
xxd -l 10 capture_fixed.pcap
Cette fois, le résultat doit être :
00000000: d4c3 b2a1 0200 0400 0000

Le fichier peut maintenant être ouvert normalement dans Wireshark :
wireshark capture_fixed.pcap
On peut également vérifier rapidement que Wireshark/TShark reconnaît bien la capture :
capinfos capture_fixed.pcap
ou :
tshark -r capture_fixed.pcap -c 5
Cette altération de l’en-tête constitue donc une première petite étape d’anti-forensics : le contenu de la capture reste exploitable, mais sa signature a été volontairement modifiée pour empêcher son ouverture directe.
On ouvre capture_fixed.pcap dans Wireshark.
La capture contient des paquest, tous en UDP.
On observe essentiellement le même trafic :
10.13.37.510.13.37.99000PINGUn filtre permettant d’isoler ce trafic est :
udp && ip.src == 10.13.37.5 && ip.dst == 10.13.37.9 && udp.dstport == 9000
Tous les paquets contiennent seulement quatre octets applicatifs :
50 49 4e 47
soit :
PING
Le payload ne contient donc manifestement pas directement le flag.

PINGPour confirmer que les données applicatives sont bien identiques :
50 49 4e 47, soit PING.On peut répéter l’opération sur plusieurs paquets : leur contenu applicatif reste identique.
Cela correspond exactement au leurre décrit dans l’énoncé : “the same little PING payload, over and over”.

Puisque le payload ne change pas, il faut examiner les colonnes et les champs des en-têtes.
Deux champs deviennent particulièrement intéressants :
Pour afficher le TTL directement dans la liste des paquets :
Time to Live ;On remarque alors deux populations :
TTL = 64
TTL = 113
Dans la capture :
TTL 64 : 385 paquets
TTL 113 : 119 paquets
Les paquets avec TTL = 113 ont des ports source qui ressemblent à du bruit aléatoire, principalement dans la plage 50000+.
Les paquets avec TTL = 64, en revanche, ont une structure beaucoup plus régulière.

Le filtre suivant permet donc de conserver uniquement les paquets intéressants :
ip.ttl == 64
Il reste 385 paquets.

On examine ensuite les ports source UDP.
Avec le filtre :
ip.ttl == 64
les premiers ports source ressemblent à ceci :
40115
40115
40115
40115
40115
40115
40115
40115
40104
40104
40104
40104
40104
40104
40104
40104
40052
40052
40052
40052
40052
40052
40052
40052
40100
...
Chaque valeur apparaît par groupes de 8 paquets.
Cela ressemble fortement à un encodage ASCII.
En soustrayant 40000 :
| Port source | Port - 40000 | ASCII |
|---|---|---|
| 40115 | 115 | s |
| 40104 | 104 | h |
| 40052 | 52 | 4 |
| 40100 | 100 | d |
| 40111 | 111 | o |
| 40119 | 119 | w |
On obtient :
sh4dow
Puis le motif recommence.
La capture nous fournit donc elle-même une clé répétée :
sh4dowsh4dowsh4dow...
C’est probablement ce que l’énoncé veut dire par :
“the operator left just enough on the wire to unscramble it”

Il reste à trouver les données à déchiffrer.
L’indice principal est le comportement temporel des paquets.
Après avoir filtré :
ip.ttl == 64
on peut demander à Wireshark d’afficher le temps écoulé depuis le paquet affiché précédent.
Dans Wireshark :
View
→ Time Display Format
→ Seconds Since Previous Displayed Packet
Il est important d’utiliser Previous Displayed Packet et non simplement Previous Captured Packet.
Les paquets
TTL = 113ont été filtrés et constituent du bruit. Nous voulons donc mesurer les intervalles entre les paquetsTTL = 64seulement.
La colonne Time montre alors deux groupes de délais très distincts.
Exemples observés :
0.053533
0.050998
0.045975
0.152574
0.039970
0.059731
0.046512
0.058688
...
On constate que les délais sont répartis autour de deux plages :
environ 0.035 à 0.080 seconde
environ 0.120 à 0.165 seconde
On peut donc choisir 0.100 s comme seuil :
delta < 0.100 s → 0
delta > 0.100 s → 1
Les intervalles deviennent ainsi un flux binaire.
Par exemple :
0.053533 → 0
0.050998 → 0
0.045975 → 0
0.152574 → 1
...
Il s’agit d’un covert timing channel : les données ne sont pas envoyées dans le payload, mais dans le délai entre les paquets.

Après filtrage sur :
ip.ttl == 64
on obtient 385 paquets.
Un délai est mesuré entre deux paquets.
Avec 385 paquets, on obtient donc :
385 - 1 = 384 intervalles
Ces 384 intervalles représentent 384 bits :
384 / 8 = 48 octets
Le premier paquet sert donc de référence temporelle, puis chaque paquet suivant permet de mesurer un nouveau bit.
On convertit chaque intervalle en bit avec le seuil de 100 ms :
< 100 ms → 0
> 100 ms → 1
On regroupe ensuite les bits par groupes de 8, en ordre MSB first.
On obtient 48 octets :
10 1b 55 13 14 03 42 05
05 0a 08 28 42 1b 6b 57
19 44 01 11 40 0c 5e 19
14 37 05 0a 30 03 1b 5b
6b 17 5e 1b 40 06 40 3b
0c 1f 47 06 5a 57 03 0a
Ces données ne sont toujours pas directement lisibles, ce qui correspond au mot “scrambled” de l’énoncé.
Pour chaque groupe de huit bits, le port source du paquet servant de départ à l’intervalle encode le caractère de clé associé.
Les groupes donnent :
s h 4 d o w s h 4 d o w ...
soit la clé répétée :
sh4dow
On effectue alors un XOR entre les 48 octets du ciphertext et le flux de clé.
Principe :
plaintext[i] = ciphertext[i] XOR key[i]
avec :
key = sh4dowsh4dowsh4dow...
Le résultat est :
csaw{t1m1ng_1s_3v3ryth1ng_1n_th3_s1l3nt_ch4nn3l}
La méthode peut être automatisée avec tshark.
tshark -r capture_fixed.pcap \
-Y "udp && ip.ttl == 64" \
-T fields \
-e frame.time_epoch \
-e udp.srcport > packets.tsv
Apercu dans le terminal :

Le fichier packets.tsv contient alors, pour chaque paquet utile :
timestamp source_port
On peut ensuite reconstruire le message avec Python :
Le script ci-dessous a été généré par l’IA Gemini à partir du prompt suivant puis modifié manuellement ensuite :
« J’ai extrait les paquets TTL=64 d’un PCAP dans packets.tsv avec le timestamp et le port source UDP les intervalles entre paquets semblent encoder des bits ce que je veux dire c’est : moins de 100 ms = 0, plus de 100 ms = 1. Il y a 8 bits par caractère. Le port source reste identique pendant chaque groupe de 8 paquets et semble encoder une clé avec quelque chose du style : #port - 40000 = valeur ASCII. Peux-tu me faire un script Python qui reconstruit les octets à partir du timing, récupère la clé depuis les ports source, puis XOR les deux pour afficher le message final ? »
rows = []
with open("packets.tsv", "r") as f:
for line in f:
timestamp, sport = line.strip().split("\t")
rows.append((float(timestamp), int(sport)))
bits = []
key_stream = []
for i in range(len(rows) - 1):
current_time, current_sport = rows[i]
next_time, _ = rows[i + 1]
delta = next_time - current_time
bits.append(0 if delta < 0.100 else 1)
ciphertext = bytearray()
key = []
for i in range(0, len(bits), 8):
chunk = bits[i:i + 8]
value = 0
for bit in chunk:
value = (value << 1) | bit
ciphertext.append(value)
# Les 8 paquets associés au byte utilisent le même port source
ports = [rows[j][1] for j in range(i, i + 8)]
assert len(set(ports)) == 1
key.append(chr(ports[0] - 40000))
key_stream = "".join(key)
print(f"[+] Key stream: {key_stream}")
print(f"[+] Ciphertext: {ciphertext.hex()}")
plaintext = bytes(
byte ^ ord(key_stream[i])
for i, byte in enumerate(ciphertext)
)
print(f"[+] Plaintext: {plaintext.decode()}")
Sortie :
[+] Key stream: sh4dowsh4dowsh4dowsh4dowsh4dowsh4dowsh4dowsh4dow
[+] Plaintext: csaw{t1m1ng_1s_3v3ryth1ng_1n_th3_s1l3nt_ch4nn3l}
csaw{t1m1ng_1s_3v3ryth1ng_1n_th3_s1l3nt_ch4nn3l}
Ce challenge utilise plusieurs couches de dissimulation.
Le payload UDP est volontairement inutile :
PING
Une partie des paquets est ensuite ajoutée comme bruit et peut être identifiée grâce au TTL :
TTL 113 → bruit
TTL 64 → canal utile
Les deux véritables canaux cachés sont ensuite :
Port source UDP → clé XOR
Timing → ciphertext
Le port source encode la clé en utilisant :
source_port - 40000 = valeur ASCII
ce qui révèle :
sh4dow
Les délais entre les paquets encodent quant à eux des bits :
court → 0
long → 1
Une fois les bits regroupés par octets, il suffit d’effectuer un XOR avec la clé répétée pour récupérer le flag.