// Parámetros críticos
int n = 36;  // Número de fragmentos
chunk_size = (filesize + n - 1) / n;  // División entera hacia arriba

// Algoritmo de mezcla Fisher-Yates
srand(time(NULL));  // Semilla basada en tiempo
for (int i = n-1; i > 0; i--) {
    int j = rand() % (i + 1);
    // Intercambio de índices
}

#!/usr/bin/env python3
"""
Reconstructor de PNG Shreddeado - PoC Completo
Uso: python3 reconstruct_png_from_shredded.py
"""

import struct
import zlib
import time

# Configuración
SHRED_PATH = "document.png.shredded"
OUT_PATH = "recovered_valid.png"
PNG_SIG = b'\x89PNG\r\n\x1a\n'

def parse_progress(buf):
    """
    Valida progreso de reconstrucción verificando chunks PNG completos
    Retorna: (éxito, estado, posición)
    """
    if not buf.startswith(PNG_SIG):
        return False, "no_sig", 0

    pos = len(PNG_SIG)
    buflen = len(buf)

    while True:
        # Verificar si tenemos datos suficientes para leer longitud
        if pos + 8 > buflen:
            return True, None, pos

        # Leer longitud y tipo del chunk
        length = struct.unpack(">I", buf[pos:pos+4])[0]
        ctype = buf[pos+4:pos+8]
        chunk_total = 4 + 4 + length + 4  # length + type + data + crc

        # Verificar chunk completo
        if pos + chunk_total > buflen:
            return True, None, pos

        # Extraer datos y CRC
        data_start = pos + 8
        data_end = data_start + length
        crc_actual = struct.unpack(">I", buf[data_end:data_end+4])[0]

        # Calcular CRC
        crc_calc = zlib.crc32(buf[pos+4:data_end]) & 0xffffffff

        # Validar
        if crc_actual != crc_calc:
            return False, f"crc_mismatch {ctype!r}", pos

        pos += chunk_total

        # Terminar si encontramos IEND
        if ctype == b'IEND':
            return True, "done", pos

def detect_candidates(data, max_n=100):
    """
    Detecta candidatos de n probando divisiones y buscando cabecera PNG
    """
    filesize = len(data)
    candidates = []

    for n in range(2, max_n + 1):
        chunk_size = (filesize + n - 1) // n
        chunks = [data[i * chunk_size:(i + 1) * chunk_size] for i in range(n)]

        # Buscar chunks que comiencen con firma PNG
        starts = [i for i, ch in enumerate(chunks) if ch.startswith(PNG_SIG)]

        if starts:
            candidates.append((n, chunk_size, starts))

    return candidates

def attempt_reconstruct(data, n, chunk_size, starts, step_limit=3_000_000):
    """
    Intenta reconstruir el archivo usando DFS con poda por CRC
    """
    chunks = [bytearray(data[i * chunk_size:(i + 1) * chunk_size]) for i in range(n)]
    visited = 0
    found_order = None
    start_time = time.time()

    def dfs(buf, used_mask, order):
        nonlocal visited, found_order

        visited += 1
        if visited % 100000 == 0:
            print(f"[+] Nodos visitados: {visited:,}, Tiempo: {time.time() - start_time:.1f}s")

        # Validar progreso actual
        ok, status, pos = parse_progress(buf)
        if not ok:
            return False

        # Verificar si terminamos
        if status == "done":
            found_order = order.copy()
            return True

        # Probar siguientes chunks
        for i in range(n):
            if used_mask & (1 << i):
                continue

            new_buf = buf + bytes(chunks[i])
            ok2, status2, pos2 = parse_progress(new_buf)

            if not ok2:
                continue

            if dfs(new_buf, used_mask | (1 << i), order + [i]):
                return True

            if visited > step_limit:
                return False

        return False

    # Intentar desde cada posible inicio
    for si in starts:
        print(f"[*] Probando inicio {si} para n={n}")
        if dfs(bytes(chunks[si]), 1 << si, [si]):
            break

    if found_order:
        # Reconstruir archivo final
        out_data = b"".join(chunks[i] for i in found_order)
        with open(OUT_PATH, "wb") as f:
            f.write(out_data)
        print(f"[+] Archivo reconstruido: {OUT_PATH}")
        return True, found_order

    print("[-] No se encontró orden válido dentro del límite")
    return False, None

def main():
    """Función principal"""
    print("[*] Cargando archivo shreddeado...")
    data = open(SHRED_PATH, "rb").read()
    print(f"[*] Tamaño del archivo: {len(data):,} bytes")

    # Detectar candidatos
    print("[*] Buscando candidatos de n...")
    candidates = detect_candidates(data, max_n=100)
    print(f"[*] Candidatos encontrados: {candidates}")

    # Intentar reconstrucción para cada candidato
    for n, chunk_size, starts in candidates:
        print(f"[*] Probando n={n}, chunk_size={chunk_size}, starts={starts}")
        success, order = attempt_reconstruct(data, n, chunk_size, starts)

        if success:
            print(f"[+] ¡Reconstrucción exitosa!")
            print(f"[+] Orden encontrado: {order}")
            return

    print("[-] Reconstrucción fallida para todos los candidatos")

if __name__ == "__main__":
    main()

// Implementación más segura
void secure_shred(FILE *f) {
    // 1. Sobrescribir con datos aleatorios
    // 2. Cifrar con clave efímera
    // 3. Fragmentar y mezclar
    // 4. Corromper cabeceras y CRCs
}