1
import base64
2
import os
3
import re
4
import shutil
5
import subprocess
6
import sys
7

8
HEX_RE = re.compile(r"[0-9a-fA-F]+")
9

10
def to_wsl_path(path: str) -> str:
11
    """Convertit un chemin Windows en chemin WSL si nécessaire."""
12
    path = os.path.abspath(path)
13
    if re.match(r"^[a-zA-Z]:\\\\", path):
14
        drive = path[0].lower()
15
        rest = path[2:].replace("\\", "/")
16
        return f"/mnt/{drive}{rest}"
17
    return path.replace("\\", "/")
18

19
def tshark_cmd() -> list[str]:
20
    """Détecte si on doit utiliser tshark directement ou via wsl."""
21
    if shutil.which("tshark"):
22
        return ["tshark"]
23
    return ["wsl", "tshark"]
24

25
def parse_padn_hex(padn_field: str) -> str:
26
    """
27
    Extrait la première valeur PadN comme une chaîne hex contiguë.
28
    Tshark peut retourner plusieurs options séparées par des virgules.
29
    """
30
    if not padn_field:
31
        return ""
32
    # On prend le premier champ avant la virgule
33
    first = padn_field.split(",", 1)[0].strip()
34
    # On nettoie pour ne garder que l'hexa
35
    hex_str = "".join(HEX_RE.findall(first))
36
    return hex_str.lower()
37

38
def solve() -> None:
39
    # --- CONFIGURATION ---
40
    pcap_file = "chall.pcap"  # <--- Vérifie le nom de ton fichier ici
41

42
    # Filtre Wireshark :
43
    # 1. Identifiant 0xbeef
44
    # 2. Présence de Hop-by-Hop
45
    # 3. Présence de PadN
46
    display_filter = "icmpv6.echo.identifier == 0xbeef && ipv6.hopopts && ipv6.opt.padn"
47

48
    cmd = tshark_cmd()
49

50
    # Gestion du chemin pour WSL si nécessaire
51
    if cmd[0] == "wsl":
52
        if not os.path.exists(pcap_file):
53
            print(f"[-] Erreur: Le fichier {pcap_file} est introuvable.")
54
            return
55
        pcap_arg = to_wsl_path(pcap_file)
56
    else:
57
        if not os.path.exists(pcap_file):
58
            print(f"[-] Erreur: Le fichier {pcap_file} est introuvable.")
59
            return
60
        pcap_arg = pcap_file
61

62
    # Commande tshark pour extraire sequence_number et padn
63
    tshark_args = cmd + [
64
        "-r", pcap_arg,
65
        "-Y", display_filter,
66
        "-T", "fields",
67
        "-E", "separator=\t",
68
        "-E", "occurrence=a",
69
        "-E", "quote=n",
70
        "-e", "icmpv6.echo.sequence_number",
71
        "-e", "ipv6.opt.padn",
72
    ]
73

74
    print(f"[*] Analyse de {pcap_file} avec tshark...")
75
    try:
76
        proc = subprocess.Popen(tshark_args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
77
        stdout, stderr = proc.communicate()
78
    except FileNotFoundError:
79
        print("[-] Erreur : tshark n'est pas installé ou n'est pas dans le PATH.")
80
        return
81

82
    if proc.returncode != 0:
83
        print(f"[-] Erreur tshark (code={proc.returncode}):")
84
        print(stderr.strip())
85
        return
86

87
    rows: list[tuple[int, bytes]] = []
88

89
    # Parsing des résultats
90
    for line in stdout.splitlines():
91
        if not line.strip():
92
            continue
93
        parts = line.split("\t")
94
        if len(parts) < 2:
95
            continue
96

97
        try:
98
            seq = int(parts[0].strip())
99
        except ValueError:
100
            continue
101

102
        pad_hex = parse_padn_hex(parts[1].strip())
103

104
        # On ignore les petits paddings d'alignement (ex: 2 octets = 4 chars hex)
105
        # On cherche le payload de 8 octets (16 chars hex)
106
        if len(pad_hex) < 16:
107
            continue
108

109
        try:
110
            pad_bytes = bytes.fromhex(pad_hex)
111
        except ValueError:
112
            continue
113

114
        rows.append((seq, pad_bytes))
115

116
    if not rows:
117
        print("[-] Aucun paquet correspondant trouvé.")
118
        print("    Vérifie que le PCAP est bon et que l'ID est bien 0xbeef.")
119
        return
120

121
    # Tri par numéro de séquence pour remettre dans l'ordre
122
    rows.sort(key=lambda x: x[0])
123

124
    print(f"[*] {len(rows)} morceaux trouvés. Reconstitution...")
125

126
    # Reconstitution Base64 avec le XOR 0x42
127
    # Chaque paquet contient 8 octets qui doivent être XORés
128
    key = 0x42
129
    b64_fragments = []
130

131
    for _, pad_bytes in rows:
132
        # Pour chaque octet b du PadN, on fait b XOR 0x42
133
        fragment = "".join(chr(key ^ b) for b in pad_bytes)
134
        b64_fragments.append(fragment)
135

136
    full_b64 = "".join(b64_fragments)
137
    print(f"[*] Chaîne Base64 reconstruite : {full_b64}")
138

139
    # Décodage final
140
    try:
141
        decoded = base64.b64decode(full_b64, validate=True)
142
        flag = decoded.decode("utf-8", errors="replace")
143
        print("\n" + "="*40)
144
        print(f"RESULTAT FINAL : {flag}")
145
        print("="*40)
146
    except Exception as e:
147
        print(f"[-] Erreur de décodage Base64 : {e}")
148
        # Tentative en mode relax (ajout de padding si manquant)
149
        try:
150
            decoded = base64.b64decode(full_b64 + "==")
151
            print(f"[?] Tentative avec padding forcé : {decoded.decode('utf-8', errors='replace')}")
152
        except:
153
            pass
154

155
if __name__ == "__main__":
156
    solve()

1
shellmates{h0p_by_h0p_0pt10ns_h1d3_s3cr3ts_1n_pl41n_s1ght}