packet-tracer-skill 0.1.0

package/scripts/packet_tracer_env.py

@@ -0,0 +1,278 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+
+
+DEFAULT_INSTALL_CANDIDATES = [
+    Path(r"C:\Program Files\Cisco Packet Tracer 9.0.0"),
+    Path(r"C:\Program Files\Cisco Packet Tracer"),
+    Path(r"C:\Program Files (x86)\Cisco Packet Tracer 9.0.0"),
+    Path(r"C:\Program Files (x86)\Cisco Packet Tracer"),
+]
+DEFAULT_PACKET_TRACER_TARGET_VERSION = "9.0.0.0810"
+DEFAULT_DONOR_FALLBACKS = [
+    Path.home() / "Downloads",
+    Path.home() / "Documents",
+    Path.home() / "Desktop",
+]
+DEFAULT_SAMPLE_DONOR_FILES = [
+    Path(r"01 Networking\FTP\FTP.pkt"),
+    Path(r"01 Networking\HTTPS\HTTPS.pkt"),
+    Path(r"01 Networking\DNS\Multilevel_DNS.pkt"),
+    Path(r"01 Networking\DHCP\dhcp_snooping_trusted_untrusted_gigabit_ports.pkt"),
+]
+
+
+@dataclass(frozen=True)
+class CompatibilityDonorDetails:
+    target_version: str
+    resolved_path: Path | None
+    donor_version: str | None
+    donor_source: str | None
+    status: str
+    blocking_reason: str
+    candidate_paths: list[tuple[str, Path]]
+
+
+def _existing_path(raw: str | None) -> Path | None:
+    if not raw:
+        return None
+    path = Path(raw).expanduser()
+    return path if path.exists() else None
+
+
+def get_packet_tracer_root() -> Path | None:
+    env_root = _existing_path(os.getenv("PACKET_TRACER_ROOT"))
+    if env_root is not None:
+        return env_root
+    for candidate in DEFAULT_INSTALL_CANDIDATES:
+        if candidate.exists():
+            return candidate
+    return None
+
+
+def get_packet_tracer_saves_root() -> Path | None:
+    env_saves = _existing_path(os.getenv("PACKET_TRACER_SAVES_ROOT"))
+    if env_saves is not None:
+        return env_saves
+    root = get_packet_tracer_root()
+    if root is None:
+        return None
+    saves = root / "saves"
+    return saves if saves.exists() else None
+
+
+def get_packet_tracer_exe() -> Path | None:
+    env_exe = _existing_path(os.getenv("PACKET_TRACER_EXE"))
+    if env_exe is not None:
+        return env_exe
+    root = get_packet_tracer_root()
+    if root is None:
+        return None
+    for candidate in [root / "bin" / "PacketTracer.exe", root / "PacketTracer.exe"]:
+        if candidate.exists():
+            return candidate
+    return None
+
+
+def require_packet_tracer_saves_root() -> Path:
+    saves = get_packet_tracer_saves_root()
+    if saves is None:
+        raise FileNotFoundError(
+            "Packet Tracer sample saves were not found. Set PACKET_TRACER_SAVES_ROOT or PACKET_TRACER_ROOT."
+        )
+    return saves
+
+
+def require_packet_tracer_exe() -> Path:
+    exe = get_packet_tracer_exe()
+    if exe is None:
+        raise FileNotFoundError(
+            "Packet Tracer executable was not found. Set PACKET_TRACER_EXE or PACKET_TRACER_ROOT."
+        )
+    return exe
+
+
+def resolve_sample_path(relative_path: str) -> Path:
+    return require_packet_tracer_saves_root() / relative_path
+
+
+def get_packet_tracer_target_version() -> str:
+    return os.getenv("PACKET_TRACER_TARGET_VERSION", DEFAULT_PACKET_TRACER_TARGET_VERSION)
+
+
+def _pkt_version(pkt_path: Path) -> str | None:
+    try:
+        from pkt_codec import decode_pkt_modern
+
+        root = ET.fromstring(decode_pkt_modern(pkt_path.read_bytes()))
+    except Exception:
+        return None
+    return root.findtext("./VERSION")
+
+
+def _candidate_pkt_files(directory: Path, source: str) -> list[tuple[str, Path]]:
+    if not directory.exists() or not directory.is_dir():
+        return []
+    candidates = sorted(
+        (path for path in directory.glob("*.pkt") if path.is_file()),
+        key=lambda path: (path.stat().st_mtime, path.name.lower()),
+        reverse=True,
+    )
+    return [(source, candidate) for candidate in candidates]
+
+
+def list_packet_tracer_compatibility_donor_candidates() -> list[tuple[str, Path]]:
+    candidates: list[tuple[str, Path]] = []
+    seen: set[str] = set()
+
+    env_donor = os.getenv("PACKET_TRACER_COMPAT_DONOR")
+    if env_donor:
+        env_path = Path(env_donor).expanduser()
+        seen.add(str(env_path).lower())
+        candidates.append(("env", env_path))
+
+    for directory in DEFAULT_DONOR_FALLBACKS:
+        for source, candidate in _candidate_pkt_files(directory, f"auto:{directory.name.lower()}"):
+            key = str(candidate).lower()
+            if key in seen:
+                continue
+            seen.add(key)
+            candidates.append((source, candidate))
+
+    saves_root = get_packet_tracer_saves_root()
+    if saves_root is not None:
+        for relative_path in DEFAULT_SAMPLE_DONOR_FILES:
+            candidate = saves_root / relative_path
+            key = str(candidate).lower()
+            if key in seen:
+                continue
+            seen.add(key)
+            candidates.append(("auto:packet-tracer-saves", candidate))
+
+    return candidates
+
+
+def inspect_packet_tracer_compatibility_donor() -> CompatibilityDonorDetails:
+    target_version = get_packet_tracer_target_version()
+    candidates = list_packet_tracer_compatibility_donor_candidates()
+    env_donor = os.getenv("PACKET_TRACER_COMPAT_DONOR")
+
+    if env_donor:
+        env_path = Path(env_donor).expanduser()
+        if not env_path.exists():
+            return CompatibilityDonorDetails(
+                target_version=target_version,
+                resolved_path=None,
+                donor_version=None,
+                donor_source="env",
+                status="missing",
+                blocking_reason=f"set but missing: {env_path}",
+                candidate_paths=candidates,
+            )
+        if env_path.suffix.lower() != ".pkt":
+            return CompatibilityDonorDetails(
+                target_version=target_version,
+                resolved_path=None,
+                donor_version=None,
+                donor_source="env",
+                status="invalid_extension",
+                blocking_reason=f"compatibility donor must be a .pkt file: {env_path}",
+                candidate_paths=candidates,
+            )
+        donor_version = _pkt_version(env_path)
+        if donor_version is None:
+            return CompatibilityDonorDetails(
+                target_version=target_version,
+                resolved_path=None,
+                donor_version=None,
+                donor_source="env",
+                status="decode_error",
+                blocking_reason=f"could not decode donor version: {env_path}",
+                candidate_paths=candidates,
+            )
+        if donor_version != target_version:
+            return CompatibilityDonorDetails(
+                target_version=target_version,
+                resolved_path=None,
+                donor_version=donor_version,
+                donor_source="env",
+                status="version_mismatch",
+                blocking_reason=f"{env_path} is version {donor_version}; expected {target_version}",
+                candidate_paths=candidates,
+            )
+        return CompatibilityDonorDetails(
+            target_version=target_version,
+            resolved_path=env_path,
+            donor_version=donor_version,
+            donor_source="env",
+            status="ok",
+            blocking_reason="",
+            candidate_paths=candidates,
+        )
+
+    decode_failures = 0
+    wrong_version_count = 0
+    for source, candidate in candidates:
+        if not candidate.exists() or candidate.suffix.lower() != ".pkt":
+            continue
+        donor_version = _pkt_version(candidate)
+        if donor_version is None:
+            decode_failures += 1
+            continue
+        if donor_version != target_version:
+            wrong_version_count += 1
+            continue
+        return CompatibilityDonorDetails(
+            target_version=target_version,
+            resolved_path=candidate,
+            donor_version=donor_version,
+            donor_source=source,
+            status="ok",
+            blocking_reason="",
+            candidate_paths=candidates,
+        )
+
+    if candidates:
+        if decode_failures == len(candidates):
+            reason = (
+                "donor candidates were found, but none could be decoded. "
+                "Check the local Twofish bridge and Python 3.14 runtime."
+            )
+        elif wrong_version_count > 0:
+            reason = f"no Packet Tracer {target_version} donor was found among the discovered local candidates"
+        else:
+            reason = f"no compatible Packet Tracer {target_version} donor was found"
+    else:
+        reason = (
+            "no donor candidates were discovered. Set PACKET_TRACER_COMPAT_DONOR "
+            "or place a working 9.0 donor lab in Downloads, Documents, Desktop, or Packet Tracer saves."
+        )
+
+    return CompatibilityDonorDetails(
+        target_version=target_version,
+        resolved_path=None,
+        donor_version=None,
+        donor_source=None,
+        status="missing",
+        blocking_reason=reason,
+        candidate_paths=candidates,
+    )
+
+
+def get_packet_tracer_compatibility_donor() -> Path | None:
+    details = inspect_packet_tracer_compatibility_donor()
+    return details.resolved_path if details.status == "ok" else None
+
+
+def require_packet_tracer_compatibility_donor() -> Path:
+    details = inspect_packet_tracer_compatibility_donor()
+    if details.status != "ok" or details.resolved_path is None:
+        raise FileNotFoundError(
+            "Packet Tracer 9.0 compatibility donor was not found. "
+            f"{details.blocking_reason}"
+        )
+    return details.resolved_path

package/scripts/pkt_builder.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from pkt_transformer import transform_from_blueprint
+from sample_catalog import load_catalog
+from sample_selector import select_best_sample
+
+
+def build_packet_tracer_xml(blueprint: dict) -> bytes:
+    samples = load_catalog()
+    device_requirements: dict[str, int] = {}
+    for device in blueprint.get("devices", []):
+        device_type = str(device["type"])
+        device_requirements[device_type] = device_requirements.get(device_type, 0) + 1
+    selected = select_best_sample(samples, list(blueprint.get("capabilities", [])), device_requirements)
+    return transform_from_blueprint(blueprint, selected)

package/scripts/pkt_codec.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import struct
+import zlib
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from vendor.twofish import Twofish
+
+
+BLOCK_SIZE = 16
+TAG_LEN = 16
+NEW_KEY = bytes([0x89]) * 16
+NEW_IV = bytes([0x10]) * 16
+
+
+def _twofish_cls() -> type["Twofish"]:
+    try:
+        from vendor.twofish import Twofish
+    except ImportError as exc:
+        raise ImportError(
+            "Packet Tracer modern codec requires a local Twofish bridge. "
+            "Set PKT_TWOFISH_LIBRARY or place a local _twofish binary next to scripts/vendor/twofish.py."
+        ) from exc
+    return Twofish
+
+
+def qcompress(xml_bytes: bytes) -> bytes:
+    if not isinstance(xml_bytes, bytes):
+        raise TypeError("xml_bytes must be bytes")
+    return struct.pack(">I", len(xml_bytes)) + zlib.compress(xml_bytes, 9)
+
+
+def quncompress(blob: bytes) -> bytes:
+    if len(blob) < 4:
+        raise ValueError("qCompress blob is too short")
+    size = struct.unpack(">I", blob[:4])[0]
+    out = zlib.decompress(blob[4:])
+    return out[:size]
+
+
+def stage2_xor(data: bytes) -> bytes:
+    length = len(data)
+    return bytes(byte ^ ((length - index) & 0xFF) for index, byte in enumerate(data))
+
+
+def stage1_obfuscate(clear: bytes) -> bytes:
+    length = len(clear)
+    out = bytearray(length)
+    for index, byte in enumerate(clear):
+        out[length - 1 - index] = byte ^ ((length - index * length) & 0xFF)
+    return bytes(out)
+
+
+def stage1_deobfuscate(obfuscated: bytes) -> bytes:
+    length = len(obfuscated)
+    return bytes(
+        obfuscated[length - 1 - index] ^ ((length - index * length) & 0xFF)
+        for index in range(length)
+    )
+
+
+def _xor_bytes(left: bytes, right: bytes) -> bytes:
+    return bytes(a ^ b for a, b in zip(left, right))
+
+
+def _gf_double(block: bytes) -> bytes:
+    value = int.from_bytes(block, "big")
+    carry = (value >> 127) & 1
+    value = ((value << 1) & ((1 << 128) - 1))
+    if carry:
+        value ^= 0x87
+    return value.to_bytes(16, "big")
+
+
+def _pad_cmac(block: bytes) -> bytes:
+    return block + b"\x80" + b"\x00" * (BLOCK_SIZE - len(block) - 1)
+
+
+def _iterate_blocks(data: bytes) -> list[bytes]:
+    return [data[index : index + BLOCK_SIZE] for index in range(0, len(data), BLOCK_SIZE)]
+
+
+def _cmac(cipher: "Twofish", data: bytes) -> bytes:
+    zero = b"\x00" * BLOCK_SIZE
+    l_val = cipher.encrypt(zero)
+    k1 = _gf_double(l_val)
+    k2 = _gf_double(k1)
+
+    blocks = _iterate_blocks(data)
+    if not blocks:
+        blocks = [b""]
+
+    if len(blocks[-1]) == BLOCK_SIZE:
+        last = _xor_bytes(blocks[-1], k1)
+    else:
+        last = _xor_bytes(_pad_cmac(blocks[-1]), k2)
+    blocks[-1] = last
+
+    state = zero
+    for block in blocks:
+        if len(block) != BLOCK_SIZE:
+            raise ValueError("CMAC internal block must be 16 bytes")
+        state = cipher.encrypt(_xor_bytes(state, block))
+    return state
+
+
+def _omac(cipher: "Twofish", domain: int, data: bytes) -> bytes:
+    prefix = b"\x00" * 15 + bytes([domain & 0xFF])
+    return _cmac(cipher, prefix + data)
+
+
+def _ctr_crypt(cipher: "Twofish", initial_counter: bytes, data: bytes) -> bytes:
+    counter = int.from_bytes(initial_counter, "big")
+    out = bytearray()
+    for offset in range(0, len(data), BLOCK_SIZE):
+        block = data[offset : offset + BLOCK_SIZE]
+        keystream = cipher.encrypt(counter.to_bytes(16, "big"))
+        out.extend(bytes(a ^ b for a, b in zip(block, keystream)))
+        counter = (counter + 1) % (1 << 128)
+    return bytes(out)
+
+
+def eax_twofish_encrypt(plaintext: bytes, nonce: bytes = NEW_IV, header: bytes = b"") -> tuple[bytes, bytes]:
+    cipher = _twofish_cls()(NEW_KEY)
+    nonce_mac = _omac(cipher, 0, nonce)
+    header_mac = _omac(cipher, 1, header)
+    ciphertext = _ctr_crypt(cipher, nonce_mac, plaintext)
+    body_mac = _omac(cipher, 2, ciphertext)
+    tag = _xor_bytes(_xor_bytes(nonce_mac, header_mac), body_mac)
+    return ciphertext, tag
+
+
+def eax_twofish_decrypt(ciphertext: bytes, tag: bytes, nonce: bytes = NEW_IV, header: bytes = b"") -> bytes:
+    if len(tag) != TAG_LEN:
+        raise ValueError("invalid EAX tag length")
+    cipher = _twofish_cls()(NEW_KEY)
+    nonce_mac = _omac(cipher, 0, nonce)
+    header_mac = _omac(cipher, 1, header)
+    body_mac = _omac(cipher, 2, ciphertext)
+    expected_tag = _xor_bytes(_xor_bytes(nonce_mac, header_mac), body_mac)
+    if expected_tag != tag:
+        raise ValueError("EAX authentication tag verification failed")
+    return _ctr_crypt(cipher, nonce_mac, ciphertext)
+
+
+def encode_pkt_modern(xml_bytes: bytes) -> bytes:
+    payload = qcompress(xml_bytes)
+    stage2 = stage2_xor(payload)
+    ciphertext, tag = eax_twofish_encrypt(stage2)
+    return stage1_obfuscate(ciphertext + tag)
+
+
+def decode_pkt_modern(pkt_bytes: bytes) -> bytes:
+    if len(pkt_bytes) < TAG_LEN:
+        raise ValueError("pkt blob is too short")
+    stage1 = stage1_deobfuscate(pkt_bytes)
+    ciphertext = stage1[:-TAG_LEN]
+    tag = stage1[-TAG_LEN:]
+    stage2 = eax_twofish_decrypt(ciphertext, tag)
+    payload = stage2_xor(stage2)
+    return quncompress(payload)
+
+
+def encode_xml_file(xml_path: str | Path, output_path: str | Path) -> Path:
+    xml_path = Path(xml_path)
+    output_path = Path(output_path)
+    pkt_bytes = encode_pkt_modern(xml_path.read_bytes())
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_bytes(pkt_bytes)
+    return output_path
+
+
+def decode_pkt_file(pkt_path: str | Path, xml_out_path: str | Path) -> Path:
+    pkt_path = Path(pkt_path)
+    xml_out_path = Path(xml_out_path)
+    xml_bytes = decode_pkt_modern(pkt_path.read_bytes())
+    xml_out_path.parent.mkdir(parents=True, exist_ok=True)
+    xml_out_path.write_bytes(xml_bytes)
+    return xml_out_path