Upload 16 files

.dockerignore

@@ -0,0 +1,13 @@
+__pycache__/
+*.py[cod]
+*$py.class
+.env
+.git/
+.vscode/
+.idea/
+*.pkt
+*.pka
+test_*.py
+Dockerfile
+.dockerignore
+requirements.txt

.env

@@ -0,0 +1,2 @@
+GHAYMAH_BASE_URL=https://genai.ghaymah.systems
+GHAYMAH_GENERATE_AI_KEY=sk-iKzhUlwdPKlGDhKDAi53Wg

Decipher/__init__.py

@@ -0,0 +1 @@
+# Decipher package

Decipher/cisco_pwd.py

@@ -0,0 +1,34 @@
+def decrypt_cisco_type7(encrypted_hex):
+    """
+    Decrypts Cisco Type 7 passwords.
+    """
+    if not encrypted_hex or len(encrypted_hex) < 4:
+        return None
+        
+    # Cisco Type 7 key
+    key = [
+        0x64, 0x73, 0x66, 0x64, 0x3b, 0x6b, 0x66, 0x6f, 
+        0x41, 0x2c, 0x2e, 0x69, 0x79, 0x65, 0x77, 0x72, 
+        0x6b, 0x6c, 0x64, 0x4a, 0x4b, 0x44, 0x48, 0x53, 
+        0x55, 0x42
+    ]
+    
+    try:
+        # First two digits are the index into the key
+        index = int(encrypted_hex[:2])
+        encrypted_data = encrypted_hex[2:]
+        
+        decrypted = ""
+        for i in range(0, len(encrypted_data), 2):
+            # Get the next byte from the hex string
+            char_hex = encrypted_data[i:i+2]
+            char_code = int(char_hex, 16)
+            
+            # XOR with the key and advance index
+            decrypted_char = chr(char_code ^ key[index % len(key)])
+            decrypted += decrypted_char
+            index += 1
+            
+        return decrypted
+    except:
+        return None

Decipher/cmac.py

@@ -0,0 +1,58 @@
+from typing import Callable
+
+BLOCK_SIZE = 16  # 128 bit for Twofish
+
+def xor_bytes(a: bytes, b: bytes) -> bytes:
+    return bytes(x ^ y for x, y in zip(a, b))
+
+def left_shift_one(bitstring: bytes) -> bytes:
+    out = bytearray(len(bitstring))
+    carry = 0
+    for i in reversed(range(len(bitstring))):
+        new = (bitstring[i] << 1) & 0xFF
+        out[i] = new | carry
+        carry = (bitstring[i] & 0x80) >> 7
+    return bytes(out)
+
+def generate_subkeys(encrypt_block: Callable[[bytes], bytes]):
+    const_rb = 0x87
+    zero = bytes(BLOCK_SIZE)
+    L = encrypt_block(zero)
+
+    K1 = left_shift_one(L)
+    if L[0] & 0x80:
+        K1 = xor_bytes(K1, b'\x00' * 15 + bytes([const_rb]))
+
+    K2 = left_shift_one(K1)
+    if K1[0] & 0x80:
+        K2 = xor_bytes(K2, b'\x00' * 15 + bytes([const_rb]))
+
+    return K1, K2
+
+def pad(block: bytes) -> bytes:
+    padded = block + b'\x80'
+    return padded + b'\x00' * (BLOCK_SIZE - len(padded))
+
+class CMAC:
+    def __init__(self, encrypt_block: Callable[[bytes], bytes]):
+        self.encrypt_block = encrypt_block
+        self.K1, self.K2 = generate_subkeys(encrypt_block)
+
+    def digest(self, data: bytes) -> bytes:
+        if len(data) == 0:
+            last = xor_bytes(pad(b''), self.K2)
+            blocks = []
+        else:
+            blocks = [data[i:i+BLOCK_SIZE] for i in range(0, len(data), BLOCK_SIZE)]
+            if len(blocks[-1]) == BLOCK_SIZE:
+                last = xor_bytes(blocks[-1], self.K1)
+                blocks = blocks[:-1]
+            else:
+                last = xor_bytes(pad(blocks[-1]), self.K2)
+                blocks = blocks[:-1]
+
+        X = bytes(BLOCK_SIZE)
+        for block in blocks:
+            X = self.encrypt_block(xor_bytes(X, block))
+
+        return self.encrypt_block(xor_bytes(X, last))

Decipher/ctr.py

@@ -0,0 +1,33 @@
+from typing import Callable
+
+BLOCK_SIZE = 16  # 128 bit
+
+
+def inc_counter_be(counter: bytearray):
+    """Incrementa un contatore big-endian a 128 bit (come Crypto++)."""
+    for i in range(BLOCK_SIZE - 1, -1, -1):
+        counter[i] = (counter[i] + 1) & 0xFF
+        if counter[i] != 0:
+            break
+
+
+class CTR:
+    def __init__(self, encrypt_block: Callable[[bytes], bytes], initial_counter: bytes):
+        assert len(initial_counter) == BLOCK_SIZE
+        self.encrypt_block = encrypt_block
+        self.counter = bytearray(initial_counter)
+
+    def process(self, data: bytes) -> bytes:
+        out = bytearray()
+        offset = 0
+
+        while offset < len(data):
+            keystream = self.encrypt_block(bytes(self.counter))
+            inc_counter_be(self.counter)
+
+            block = data[offset:offset + BLOCK_SIZE]
+            ks = keystream[:len(block)]
+            out.extend(b ^ k for b, k in zip(block, ks))
+            offset += BLOCK_SIZE
+
+        return bytes(out)

Decipher/eax.py

@@ -0,0 +1,53 @@
+from typing import Callable
+from Decipher.cmac import CMAC, xor_bytes, BLOCK_SIZE
+from Decipher.ctr import CTR
+
+
+def _omac_with_prefix(cmac: CMAC, prefix: int, data: bytes) -> bytes:
+    # Prefisso di 16 byte: [0, 0, ..., prefix]
+    P = b'\x00' * (BLOCK_SIZE - 1) + bytes([prefix])
+    return cmac.digest(P + data)
+
+
+class EAX:
+    def __init__(self, encrypt_block: Callable[[bytes], bytes]):
+        self.encrypt_block = encrypt_block
+        self.cmac = CMAC(encrypt_block)
+
+    def encrypt(self, nonce: bytes, plaintext: bytes, aad: bytes = b''):
+        # OMAC_0 = CMAC(0x00 || nonce)
+        n_tag = _omac_with_prefix(self.cmac, 0x00, nonce)
+
+        # OMAC_1 = CMAC(0x01 || aad)
+        h_tag = _omac_with_prefix(self.cmac, 0x01, aad)
+
+        # CTR parte da n_tag
+        ctr = CTR(self.encrypt_block, n_tag)
+        ciphertext = ctr.process(plaintext)
+
+        # OMAC_2 = CMAC(0x02 || ciphertext)
+        c_tag = _omac_with_prefix(self.cmac, 0x02, ciphertext)
+
+        # TAG finale = n_tag ⊕ h_tag ⊕ c_tag
+        tag = xor_bytes(xor_bytes(n_tag, h_tag), c_tag)
+
+        return ciphertext, tag
+
+    def decrypt(self, nonce: bytes, ciphertext: bytes, tag: bytes, aad: bytes = b''):
+        # Ricalcolo OMAC_0
+        n_tag = _omac_with_prefix(self.cmac, 0x00, nonce)
+
+        # CTR
+        ctr = CTR(self.encrypt_block, n_tag)
+        plaintext = ctr.process(ciphertext)
+
+        # Ricalcolo OMAC_1 e OMAC_2
+        h_tag = _omac_with_prefix(self.cmac, 0x01, aad)
+        c_tag = _omac_with_prefix(self.cmac, 0x02, ciphertext)
+
+        # Verifica TAG
+        expected_tag = xor_bytes(xor_bytes(n_tag, h_tag), c_tag)
+        if expected_tag != tag:
+            raise ValueError("EAX authentication failed")
+
+        return plaintext

Decipher/extract.py

@@ -0,0 +1,299 @@
+import xml.etree.ElementTree as ET
+import re
+import base64
+from ciscoconfparse import CiscoConfParse
+from Decipher.cisco_pwd import decrypt_cisco_type7
+
+def sanitize_xml_content(xml_bytes):
+    """
+    Sanitizes XML content by properly handling problematic binary data in attributes
+    instead of just deleting them.
+    """
+    # Robust decoding
+    xml_content = xml_bytes.decode('utf-8', errors='ignore')
+    
+    def encode_binary_attr(match):
+        attr_name = match.group(1)
+        attr_value = match.group(2)
+        # Check if value contains non-XML friendly characters
+        if any(ord(c) < 32 and c not in '\n\r\t' for c in attr_value):
+            encoded = base64.b64encode(attr_value.encode('utf-8', errors='ignore')).decode('utf-8')
+            return f'{attr_name}="base64:{encoded}"'
+        return match.group(0)
+
+    # Find attributes that might contain binary data (like VALUE="...")
+    xml_content = re.sub(r'(\b\w+)="([^"]*)"', encode_binary_attr, xml_content)
+    
+    # Ensure root tag is closed if it's a snippet
+    if "</PACKETTRACER5>" not in xml_content and "<PACKETTRACER5>" in xml_content:
+        xml_content += "</PACKETTRACER5>"
+    elif "</PACKETTRACER5_ACTIVITY>" not in xml_content and "<PACKETTRACER5_ACTIVITY>" in xml_content:
+        xml_content += "</PACKETTRACER5_ACTIVITY>"
+        
+    return xml_content
+
+def extract_structured_data(xml_path):
+    try:
+        with open(xml_path, 'rb') as f:
+            xml_bytes = f.read()
+        
+        xml_content = sanitize_xml_content(xml_bytes)
+        root = ET.fromstring(xml_content)
+    except Exception as e:
+        print(f"[-] Error parsing {xml_path}: {e}")
+        return None
+
+    data = {
+        "version": root.findtext(".//VERSION"),
+        "devices": [],
+        "physical_links": [],
+        "wireless_connections": [],
+        "vlans": {},
+        "instructions": ""
+    }
+
+    # 1. Extract Devices and their properties
+    devices_by_id = {}
+    ssids_servers = {} # ssid -> device_name
+
+    for device in root.findall(".//DEVICE"):
+        engine = device.find("ENGINE")
+        if engine is None:
+            continue
+            
+        name = engine.findtext("NAME")
+        dev_type = engine.findtext("TYPE")
+        model = engine.find("TYPE").get("model") if engine.find("TYPE") is not None else ""
+        ref_id = engine.findtext("SAVE_REF_ID")
+        
+        dev_info = {
+            "name": name,
+            "type": dev_type,
+            "model": model,
+            "interfaces": [],
+            "wireless_info": None,
+            "vlans": []
+        }
+        
+        if ref_id:
+            devices_by_id[ref_id] = name
+
+        # Extract Interfaces & IP info
+        for port in engine.findall(".//PORT"):
+            port_name = port.findtext("PORT_NAME") or port.findtext("NAME")
+            if not port_name:
+                # Try to find in parent SLOT/MODULE
+                parent_module = port.find("..")
+                if parent_module is not None:
+                    port_type = port.findtext("TYPE")
+                    if port_type:
+                        port_name = port_type
+            
+            if port_name:
+                ip = port.findtext("IP")
+                subnet = port.findtext("SUBNET")
+                ipv6 = port.findtext("IPV6_LINK_LOCAL")
+                
+                if ip or ipv6 or port.findtext("PORT_DHCP_ENABLE") == "true":
+                    dev_info["interfaces"].append({
+                        "name": port_name,
+                        "ip": ip if ip else "DHCP" if port.findtext("PORT_DHCP_ENABLE") == "true" else None,
+                        "subnet": subnet,
+                        "ipv6": ipv6
+                    })
+
+        # Extract Wireless Server info (Access Points)
+        wireless_server = engine.find("WIRELESS_SERVER")
+        if wireless_server is not None:
+            common = wireless_server.find("WIRELESS_COMMON")
+            if common is not None:
+                ssid = common.findtext("SSID")
+                dev_info["wireless_info"] = {
+                    "role": "server",
+                    "ssid": ssid,
+                    "encryption": common.findtext("ENCRYPT_TYPE"),
+                    "key": common.find(".//KEY").text if common.find(".//KEY") is not None else None
+                }
+                if ssid:
+                    ssids_servers[ssid] = name
+
+        # Extract Wireless Client info (PC/Laptop/Phone)
+        wireless_client = engine.find("WIRELESS_CLIENT")
+        if wireless_client is not None:
+            common = wireless_client.find("WIRELESS_COMMON")
+            if common is not None:
+                ssid = common.findtext("SSID")
+                dev_info["wireless_info"] = {
+                    "role": "client",
+                    "ssid": ssid,
+                    "encryption": common.findtext("ENCRYPT_TYPE")
+                }
+
+        # Extract VLANs from device-specific storage (Switches)
+        vlan_storage = engine.findall(".//VLANS/VLAN")
+        for v in vlan_storage:
+            v_num = v.get("number")
+            v_name = v.get("name")
+            if v_num and v_num not in data["vlans"]:
+                data["vlans"][v_num] = v_name
+            dev_info["vlans"].append({"id": v_num, "name": v_name})
+
+        # Parse RUNNINGCONFIG using CiscoConfParse for deeper analysis
+        config = engine.findtext("RUNNINGCONFIG")
+        if config:
+            parse = CiscoConfParse(config.splitlines(), factory=True)
+            
+            # 1. Improved VLAN assignments
+            for intf_obj in parse.find_objects(r'^interface'):
+                intf_name = intf_obj.text.replace('interface ', '').strip()
+                vlan_id = None
+                
+                # Check for access vlan
+                access_vlan = intf_obj.re_search_children(r'switchport access vlan (\d+)')
+                if access_vlan:
+                    vlan_id = access_vlan[0].re_match_typed(r'switchport access vlan (\d+)')
+                
+                if vlan_id:
+                    # Update or add interface info
+                    found = False
+                    for i in dev_info["interfaces"]:
+                        if i["name"] == intf_name:
+                            i["vlan"] = vlan_id
+                            found = True
+                            break
+                    if not found:
+                        dev_info["interfaces"].append({"name": intf_name, "vlan": vlan_id})
+
+            # 2. L3/L4 Support: Routing Protocols (Static, OSPF)
+            dev_info["routing"] = {
+                "static_routes": [],
+                "ospf": [],
+                "nat": [],
+                "dhcp_pools": []
+            }
+            
+            # Static Routes
+            static_routes = parse.find_objects(r'^ip route')
+            for route in static_routes:
+                dev_info["routing"]["static_routes"].append(route.text)
+                
+            # OSPF
+            ospf_processes = parse.find_objects(r'^router ospf')
+            for ospf in ospf_processes:
+                ospf_info = {"process_id": ospf.text.split()[-1], "networks": []}
+                for network in ospf.re_search_children(r'network'):
+                    ospf_info["networks"].append(network.text.strip())
+                dev_info["routing"]["ospf"].append(ospf_info)
+
+            # NAT
+            nat_rules = parse.find_objects(r'^ip nat')
+            for rule in nat_rules:
+                dev_info["routing"]["nat"].append(rule.text)
+
+            # DHCP Pools
+            dhcp_pools = parse.find_objects(r'^ip dhcp pool')
+            for pool in dhcp_pools:
+                pool_info = {
+                    "name": pool.text.replace('ip dhcp pool ', '').strip(),
+                    "details": [child.text.strip() for child in pool.children]
+                }
+                dev_info["routing"]["dhcp_pools"].append(pool_info)
+
+            # 3. Security Audit & ACLs
+            dev_info["security"] = {
+                "acls": [],
+                "vulnerabilities": [],
+                "decrypted_passwords": []
+            }
+
+            # Decrypt Type 7 passwords
+            type7_pwds = re.findall(r'password 7 ([0-9A-Fa-f]+)|enable password 7 ([0-9A-Fa-f]+)', config)
+            for pwd_match in type7_pwds:
+                encrypted = pwd_match[0] or pwd_match[1]
+                decrypted = decrypt_cisco_type7(encrypted)
+                if decrypted:
+                    dev_info["security"]["decrypted_passwords"].append({
+                        "encrypted": encrypted,
+                        "decrypted": decrypted,
+                        "type": "Cisco Type 7"
+                    })
+                    dev_info["security"]["vulnerabilities"].append(f"Weak encryption found: Decrypted password '{decrypted}'")
+
+            # Standard and Extended ACLs
+            acls = parse.find_objects(r'^access-list|ip access-list')
+            for acl in acls:
+                acl_info = {"name": acl.text.strip(), "rules": []}
+                if acl.children:
+                    acl_info["rules"] = [child.text.strip() for child in acl.children]
+                dev_info["security"]["acls"].append(acl_info)
+
+            # Security Audit: Check for plaintext passwords or weak services
+            if parse.find_objects(r'^no service password-encryption'):
+                dev_info["security"]["vulnerabilities"].append("Plaintext password storage enabled (no service password-encryption)")
+            
+            if parse.find_objects(r'^line vty'):
+                vty_lines = parse.find_objects(r'^line vty')
+                for vty in vty_lines:
+                    if not vty.re_search_children(r'transport input ssh'):
+                        dev_info["security"]["vulnerabilities"].append(f"Insecure remote access (Telnet allowed on {vty.text.strip()})")
+            
+            # 4. Server Services (if applicable)
+            dev_info["services"] = []
+            services_node = engine.find("SERVICES")
+            if services_node is not None:
+                # HTTP Service
+                http = services_node.find("HTTP")
+                if http is not None and http.get("enabled") == "true":
+                    dev_info["services"].append({"type": "HTTP", "port": 80})
+                
+                # DNS Service
+                dns = services_node.find("DNS")
+                if dns is not None and dns.get("enabled") == "true":
+                    dns_info = {"type": "DNS", "records": []}
+                    for record in dns.findall("RECORD"):
+                        dns_info["records"].append({
+                            "name": record.get("name"),
+                            "type": record.get("type"),
+                            "value": record.get("value")
+                        })
+                    dev_info["services"].append(dns_info)
+
+        data["devices"].append(dev_info)
+
+    # 2. Extract Physical Links
+    for link in root.findall(".//LINK"):
+        cable = link.find("CABLE")
+        if cable is not None:
+            ports = cable.findall("PORT")
+            from_id = cable.findtext("FROM")
+            to_id = cable.findtext("TO")
+            
+            link_info = {
+                "type": link.findtext("TYPE"),
+                "from_device": devices_by_id.get(from_id, from_id),
+                "to_device": devices_by_id.get(to_id, to_id),
+            }
+            if len(ports) >= 2:
+                link_info["from_port"] = ports[0].text
+                link_info["to_port"] = ports[1].text
+            
+            data["physical_links"].append(link_info)
+
+    # 3. Establish Wireless Connections
+    for dev in data["devices"]:
+        if dev["wireless_info"] and dev["wireless_info"]["role"] == "client":
+            ssid = dev["wireless_info"]["ssid"]
+            if ssid in ssids_servers:
+                data["wireless_connections"].append({
+                    "from_device": dev["name"],
+                    "to_device": ssids_servers[ssid],
+                    "ssid": ssid,
+                    "type": "wireless"
+                })
+
+    # 4. Extract Instructions
+    instr_page = root.find(".//INSTRUCTIONS/PAGE")
+    if instr_page is not None:
+        data["instructions"] = instr_page.text
+
+    return data

Decipher/generator.py

@@ -0,0 +1,83 @@
+import os
+import json
+from openai import OpenAI
+from dotenv import load_dotenv
+from Decipher.models import NetworkTopology
+from Decipher.validator import validate_topology
+
+load_dotenv()
+
+client = OpenAI(
+    api_key=os.getenv("GHAYMAH_GENERATE_AI_KEY"),
+    base_url=os.getenv("GHAYMAH_BASE_URL"),
+    timeout=60.0 # Increase timeout to 60 seconds
+)
+SYSTEM_PROMPT = """
+You are a Senior Network Architect. Your task is to generate a highly accurate and valid network topology JSON based on a user's description.
+The output MUST strictly follow the provided JSON schema.
+
+Principles for accuracy:
+1. IP Addressing: Ensure devices in the same segment have unique IPs in the same subnet.
+2. Connectivity: Define physical links correctly between existing devices and ports.
+3. Routing: If OSPF or static routes are requested, ensure the configuration is logically sound.
+4. VLANs: Ensure ports are assigned to correct VLANs if specified.
+5. Device Types: Use realistic device types (Router, Switch, PC, Server, etc.) and models (e.g., 2911, 2960).
+
+You must respond ONLY with the valid JSON object. No markdown, no conversational text.
+Ensure all relevant arrays (devices, physical_links) are populated based on the user's request. Do not return empty arrays if the user asked for specific components.
+
+Example Output Structure:
+{
+  "version": "1.0",
+  "devices": [
+    {
+      "name": "Router1",
+      "type": "Router",
+      "model": "2911",
+      "interfaces": [{"name": "GigabitEthernet0/0", "ip": "192.168.1.1", "subnet": "255.255.255.0"}],
+      "routing": {"static_routes": [], "ospf": [{"process_id": "1", "networks": ["192.168.1.0 0.0.0.255 area 0"]}]}
+    }
+  ],
+  "physical_links": [
+    {"type": "Copper", "from_device": "Router1", "to_device": "Switch1", "from_port": "GigabitEthernet0/0", "to_port": "FastEthernet0/1"}
+  ],
+  "vlans": {"10": "Sales", "20": "HR"},
+  "instructions": "Brief summary of the network..."
+}
+"""
+
+
+def generate_network(prompt: str) -> NetworkTopology:
+    try:
+        response = client.chat.completions.create(
+            model="DeepSeek-V3-0324", # Using available model
+            messages=[
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": f"Generate a network topology for: {prompt}"}
+            ],
+            response_format={"type": "json_object"}
+        )
+        
+        content = response.choices[0].message.content
+        print(f"--- RAW LLM RESPONSE ---\n{content}\n-----------------------")
+        data = json.loads(content)
+        
+        if not data.get("devices") and not data.get("physical_links"):
+             # If AI returned an empty-ish object, it might have failed to understand.
+             # We can try to raise an error so the API doesn't return an empty success.
+             raise ValueError("AI generated an empty network topology. Please try a more descriptive prompt.")
+        
+        # Validate and parse into Pydantic model
+        topology = NetworkTopology(**data)
+        
+        # Intelligent Validation Layer
+        validation_issues = validate_topology(topology)
+        if validation_issues:
+            # Append issues to instructions so user is aware of logical warnings
+            issue_text = "\n\n[Accuracy Layer Warnings]:\n- " + "\n- ".join(validation_issues)
+            topology.instructions += issue_text
+            
+        return topology
+    except Exception as e:
+        print(f"Error generating network: {e}")
+        raise e

Decipher/models.py

@@ -0,0 +1,85 @@
+from pydantic import BaseModel, Field
+from typing import List, Optional, Dict, Any
+
+class Interface(BaseModel):
+    name: str
+    ip: Optional[str] = None
+    subnet: Optional[str] = None
+    ipv6: Optional[str] = None
+    vlan: Optional[str] = None
+
+class WirelessInfo(BaseModel):
+    role: str # "server" or "client"
+    ssid: Optional[str] = None
+    encryption: Optional[str] = None
+    key: Optional[str] = None
+
+class OSPFNetwork(BaseModel):
+    network: str
+
+class OSPFProcess(BaseModel):
+    process_id: str
+    networks: List[str]
+
+class Routing(BaseModel):
+    static_routes: List[str] = []
+    ospf: List[OSPFProcess] = []
+    nat: List[str] = []
+    dhcp_pools: List[Dict[str, Any]] = []
+
+class Security(BaseModel):
+    acls: List[Dict[str, Any]] = []
+    vulnerabilities: List[str] = []
+    decrypted_passwords: List[Dict[str, Any]] = []
+
+class Device(BaseModel):
+    name: str
+    type: str
+    model: Optional[str] = ""
+    interfaces: List[Interface] = []
+    wireless_info: Optional[WirelessInfo] = None
+    vlans: List[Dict[str, str]] = []
+    routing: Optional[Routing] = None
+    security: Optional[Security] = None
+    services: List[Dict[str, Any]] = []
+
+class PhysicalLink(BaseModel):
+    type: str
+    from_device: str
+    to_device: str
+    from_port: Optional[str] = None
+    to_port: Optional[str] = None
+
+class WirelessConnection(BaseModel):
+    from_device: str
+    to_device: str
+    ssid: str
+    type: str = "wireless"
+
+class NetworkTopology(BaseModel):
+    version: Optional[str] = "1.0"
+    devices: List[Device] = []
+    physical_links: List[PhysicalLink] = []
+    wireless_connections: List[WirelessConnection] = []
+    vlans: Dict[str, str] = {}
+    instructions: str = ""
+
+    model_config = {
+        "json_schema_extra": {
+            "example": {
+                "version": "1.0",
+                "devices": [
+                    {
+                        "name": "Router-ISP",
+                        "type": "Router",
+                        "model": "2911",
+                        "interfaces": [
+                            {"name": "GigabitEthernet0/0", "ip": "10.0.0.1", "subnet": "255.255.255.0"}
+                        ]
+                    }
+                ],
+                "physical_links": [],
+                "instructions": "This is an example topology."
+            }
+        }
+    }

Decipher/pt_crypto.py

@@ -0,0 +1,52 @@
+from Decipher.eax import EAX
+from Decipher.twofish import Twofish
+import zlib
+import struct
+
+def deobf_stage1(data: bytes) -> bytes:
+    L = len(data)
+    res = bytearray(L)
+    for i in range(L):
+        res[i] = data[L-1-i] ^ (L - i*L & 0xFF)
+    return bytes(res)
+
+def deobf_stage2(data: bytes) -> bytes:
+    L = len(data)
+    res = bytearray(L)
+    for i, b in enumerate(data):
+        res[i] = b ^ (L - i & 0xFF)
+    return bytes(res)
+
+def uncompress_qt(blob: bytes) -> bytes:
+    size = struct.unpack(">I", blob[:4])[0]
+    return zlib.decompress(blob[4:])[:size]
+
+def decrypt_pkt(pkt: bytes) -> bytes:
+    # Stage 1 deobfuscation
+    stage1 = deobf_stage1(pkt)
+
+    # Chiave e IV per i file .pkt
+    key = bytes([137])*16
+    iv  = bytes([16])*16
+
+    # Twofish block cipher
+    tf = Twofish(key)
+    encrypt_block = tf.encrypt
+
+    # EAX con nonce = iv
+    eax = EAX(encrypt_block)
+
+    # Supponiamo che negli .pkt il tag sia alla fine
+    ciphertext = stage1[:-16]
+    tag        = stage1[-16:]
+
+    # Decrypt usando nonce fisso
+    decrypted = eax.decrypt(nonce=iv, ciphertext=ciphertext, tag=tag)
+
+    # Stage 2 deobfuscation
+    stage2 = deobf_stage2(decrypted)
+
+    # Decompressione
+    xml = uncompress_qt(stage2)
+
+    return xml

Decipher/twofish.py

@@ -0,0 +1,393 @@
+## twofish.py - pure Python implementation of the Twofish algorithm.
+## Bjorn Edstrom <be@bjrn.se> 13 december 2007.
+##
+## Copyrights
+## ==========
+##
+## This code is a derived from an implementation by Dr Brian Gladman 
+## (gladman@seven77.demon.co.uk) which is subject to the following license.
+## This Python implementation is not subject to any other license.
+##
+##/* This is an independent implementation of the encryption algorithm:   */
+##/*                                                                      */
+##/*         Twofish by Bruce Schneier and colleagues                     */
+##/*                                                                      */
+##/* which is a candidate algorithm in the Advanced Encryption Standard   */
+##/* programme of the US National Institute of Standards and Technology.  */
+##/*                                                                      */
+##/* Copyright in this implementation is held by Dr B R Gladman but I     */
+##/* hereby give permission for its free direct or derivative use subject */
+##/* to acknowledgment of its origin and compliance with any conditions   */
+##/* that the originators of t he algorithm place on its exploitation.    */
+##/*                                                                      */
+##/* My thanks to Doug Whiting and Niels Ferguson for comments that led   */
+##/* to improvements in this implementation.                              */
+##/*                                                                      */
+##/* Dr Brian Gladman (gladman@seven77.demon.co.uk) 14th January 1999     */
+##
+## The above copyright notice must not be removed.
+##
+## Information
+## ===========
+##
+## Anyone thinking of using this code should reconsider. It's slow.
+## Try python-mcrypt instead. In case a faster library is not installed
+## on the target system, this code can be used as a portable fallback.
+
+# pylint: disable-all
+
+block_size = 16
+key_size = 32
+
+class Twofish:
+    
+    def __init__(self, key=None):
+        """Twofish."""
+
+        if key:
+            self.set_key(key)
+
+
+    def set_key(self, key):
+        """Init."""
+        
+        key_len = len(key)
+        if key_len not in [16, 24, 32]:
+            # XXX: add padding?
+            raise KeyError("key must be 16, 24 or 32 bytes")
+        if key_len % 4:
+            # XXX: add padding?
+            raise KeyError("key not a multiple of 4")
+        if key_len > 32:
+            # XXX: prune?
+            raise KeyError("key_len > 32")
+        
+        self.context = TWI()
+        
+        key_word32 = [0] * 32
+        i = 0
+        while key:
+            key_word32[i] = struct.unpack("<L", key[0:4])[0]
+            key = key[4:]
+            i += 1
+
+        set_key(self.context, key_word32, key_len)
+
+        
+    def decrypt(self, block):
+        """Decrypt blocks."""
+        
+        if len(block) % 16:
+            raise ValueError("block size must be a multiple of 16")
+
+        plaintext = b''
+        
+        while block:
+            a, b, c, d = struct.unpack("<4L", block[:16])
+            temp = [a, b, c, d]
+            decrypt(self.context, temp)
+            plaintext += struct.pack("<4L", *temp)
+            block = block[16:]
+            
+        return plaintext
+
+        
+    def encrypt(self, block):
+        """Encrypt blocks."""
+
+        if len(block) % 16:
+            raise ValueError("block size must be a multiple of 16")
+
+        ciphertext = b''
+        
+        while block:
+            a, b, c, d = struct.unpack("<4L", block[0:16])
+            temp = [a, b, c, d]
+            encrypt(self.context, temp)
+            ciphertext += struct.pack("<4L", *temp)
+            block = block[16:]
+            
+        return ciphertext
+
+
+    def get_name(self):
+        """Return the name of the cipher."""
+        
+        return "Twofish"
+
+
+    def get_block_size(self):
+        """Get cipher block size in bytes."""
+        
+        return 16
+
+    
+    def get_key_size(self):
+        """Get cipher key size in bytes."""
+        
+        return 32
+
+
+#
+# Private.
+#
+
+import struct
+import sys
+
+WORD_BIGENDIAN = 0
+if sys.byteorder == 'big':
+    WORD_BIGENDIAN = 1
+
+def rotr32(x, n):
+    return (x >> n) | ((x << (32 - n)) & 0xFFFFFFFF)
+
+def rotl32(x, n):
+    return ((x << n) & 0xFFFFFFFF) | (x >> (32 - n))
+
+def byteswap32(x):
+    return ((x & 0xff) << 24) | (((x >> 8) & 0xff) << 16) | \
+           (((x >> 16) & 0xff) << 8) | ((x >> 24) & 0xff)
+
+class TWI:
+    def __init__(self):
+        self.k_len = 0 # word32
+        self.l_key = [0]*40 # word32
+        self.s_key = [0]*4 # word32
+        self.qt_gen = 0 # word32
+        self.q_tab = [[0]*256, [0]*256] # byte
+        self.mt_gen = 0 # word32
+        self.m_tab = [[0]*256, [0]*256, [0]*256, [0]*256] # word32
+        self.mk_tab = [[0]*256, [0]*256, [0]*256, [0]*256] # word32
+
+def byte(x, n):
+    return (x >> (8 * n)) & 0xff
+
+tab_5b = [0, 90, 180, 238]
+tab_ef = [0, 238, 180, 90]
+ror4 = [0, 8, 1, 9, 2, 10, 3, 11, 4, 12, 5, 13, 6, 14, 7, 15]
+ashx = [0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, 5, 14, 7]
+qt0 = [[8, 1, 7, 13, 6, 15, 3, 2, 0, 11, 5, 9, 14, 12, 10, 4],
+       [2, 8, 11, 13, 15, 7, 6, 14, 3, 1, 9, 4, 0, 10, 12, 5]]
+qt1 = [[14, 12, 11, 8, 1, 2, 3, 5, 15, 4, 10, 6, 7, 0, 9, 13],
+       [1, 14, 2, 11, 4, 12, 3, 7, 6, 13, 10, 5, 15, 9, 0, 8]]
+qt2 = [[11, 10, 5, 14, 6, 13, 9, 0, 12, 8, 15, 3, 2, 4, 7, 1],
+       [4, 12, 7, 5, 1, 6, 9, 10, 0, 14, 13, 8, 2, 11, 3, 15]]
+qt3 = [[13, 7, 15, 4, 1, 2, 6, 14, 9, 11, 3, 0, 8, 5, 12, 10],
+       [11, 9, 5, 1, 12, 3, 13, 14, 6, 4, 7, 15, 2, 0, 8, 10]]
+
+def qp(n, x): # word32, byte
+    n %= 0x100000000
+    x %= 0x100
+    a0 = x >> 4;
+    b0 = x & 15;
+    a1 = a0 ^ b0;
+    b1 = ror4[b0] ^ ashx[a0];
+    a2 = qt0[n][a1];
+    b2 = qt1[n][b1];
+    a3 = a2 ^ b2;
+    b3 = ror4[b2] ^ ashx[a2];
+    a4 = qt2[n][a3];
+    b4 = qt3[n][b3];
+    return (b4 << 4) | a4;
+
+def gen_qtab(pkey):
+    for i in range(256):
+        pkey.q_tab[0][i] = qp(0, i)
+        pkey.q_tab[1][i] = qp(1, i)
+        
+def gen_mtab(pkey):
+    for i in range(256):
+        f01 = pkey.q_tab[1][i]
+        f01 = pkey.q_tab[1][i];
+        f5b = ((f01) ^ ((f01) >> 2) ^ tab_5b[(f01) & 3]);
+        fef = ((f01) ^ ((f01) >> 1) ^ ((f01) >> 2) ^ tab_ef[(f01) & 3]);
+        pkey.m_tab[0][i] = f01 + (f5b << 8) + (fef << 16) + (fef << 24);
+        pkey.m_tab[2][i] = f5b + (fef << 8) + (f01 << 16) + (fef << 24);
+
+        f01 = pkey.q_tab[0][i];
+        f5b = ((f01) ^ ((f01) >> 2) ^ tab_5b[(f01) & 3]);
+        fef = ((f01) ^ ((f01) >> 1) ^ ((f01) >> 2) ^ tab_ef[(f01) & 3]);
+        pkey.m_tab[1][i] = fef + (fef << 8) + (f5b << 16) + (f01 << 24);
+        pkey.m_tab[3][i] = f5b + (f01 << 8) + (fef << 16) + (f5b << 24);
+
+def gen_mk_tab(pkey, key):
+    if pkey.k_len == 2:
+        for i in range(256):
+            by = i % 0x100
+            pkey.mk_tab[0][i] = pkey.m_tab[0][pkey.q_tab[0][pkey.q_tab[0][by] ^ byte(key[1],0)] ^ byte(key[0],0)];
+            pkey.mk_tab[1][i] = pkey.m_tab[1][pkey.q_tab[0][pkey.q_tab[1][by] ^ byte(key[1],1)] ^ byte(key[0],1)];
+            pkey.mk_tab[2][i] = pkey.m_tab[2][pkey.q_tab[1][pkey.q_tab[0][by] ^ byte(key[1],2)] ^ byte(key[0],2)];
+            pkey.mk_tab[3][i] = pkey.m_tab[3][pkey.q_tab[1][pkey.q_tab[1][by] ^ byte(key[1],3)] ^ byte(key[0],3)];
+    if pkey.k_len == 3:
+        for i in range(256):
+            by = i % 0x100
+            pkey.mk_tab[0][i] = pkey.m_tab[0][pkey.q_tab[0][pkey.q_tab[0][pkey.q_tab[1][by] ^ byte(key[2], 0)] ^ byte(key[1], 0)] ^ byte(key[0], 0)];
+            pkey.mk_tab[1][i] = pkey.m_tab[1][pkey.q_tab[0][pkey.q_tab[1][pkey.q_tab[1][by] ^ byte(key[2], 1)] ^ byte(key[1], 1)] ^ byte(key[0], 1)];
+            pkey.mk_tab[2][i] = pkey.m_tab[2][pkey.q_tab[1][pkey.q_tab[0][pkey.q_tab[0][by] ^ byte(key[2], 2)] ^ byte(key[1], 2)] ^ byte(key[0], 2)];
+            pkey.mk_tab[3][i] = pkey.m_tab[3][pkey.q_tab[1][pkey.q_tab[1][pkey.q_tab[0][by] ^ byte(key[2], 3)] ^ byte(key[1], 3)] ^ byte(key[0], 3)];
+    if pkey.k_len == 4:
+        for i in range(256):
+            by = i % 0x100
+            pkey.mk_tab[0][i] = pkey.m_tab[0][pkey.q_tab[0][pkey.q_tab[0][pkey.q_tab[1][pkey.q_tab[1][by] ^ byte(key[3], 0)] ^ byte(key[2], 0)] ^ byte(key[1], 0)] ^ byte(key[0], 0)];
+            pkey.mk_tab[1][i] = pkey.m_tab[1][pkey.q_tab[0][pkey.q_tab[1][pkey.q_tab[1][pkey.q_tab[0][by] ^ byte(key[3], 1)] ^ byte(key[2], 1)] ^ byte(key[1], 1)] ^ byte(key[0], 1)];
+            pkey.mk_tab[2][i] = pkey.m_tab[2][pkey.q_tab[1][pkey.q_tab[0][pkey.q_tab[0][pkey.q_tab[0][by] ^ byte(key[3], 2)] ^ byte(key[2], 2)] ^ byte(key[1], 2)] ^ byte(key[0], 2)];
+            pkey.mk_tab[3][i] = pkey.m_tab[3][pkey.q_tab[1][pkey.q_tab[1][pkey.q_tab[0][pkey.q_tab[1][by] ^ byte(key[3], 3)] ^ byte(key[2], 3)] ^ byte(key[1], 3)] ^ byte(key[0], 3)];
+
+def h_fun(pkey, x, key):
+    b0 = byte(x, 0);
+    b1 = byte(x, 1);
+    b2 = byte(x, 2);
+    b3 = byte(x, 3);
+    if pkey.k_len >= 4:
+        b0 = pkey.q_tab[1][b0] ^ byte(key[3], 0);
+        b1 = pkey.q_tab[0][b1] ^ byte(key[3], 1);
+        b2 = pkey.q_tab[0][b2] ^ byte(key[3], 2);
+        b3 = pkey.q_tab[1][b3] ^ byte(key[3], 3);
+    if pkey.k_len >= 3:
+        b0 = pkey.q_tab[1][b0] ^ byte(key[2], 0);
+        b1 = pkey.q_tab[1][b1] ^ byte(key[2], 1);
+        b2 = pkey.q_tab[0][b2] ^ byte(key[2], 2);
+        b3 = pkey.q_tab[0][b3] ^ byte(key[2], 3);
+    if pkey.k_len >= 2:
+        b0 = pkey.q_tab[0][pkey.q_tab[0][b0] ^ byte(key[1], 0)] ^ byte(key[0], 0);
+        b1 = pkey.q_tab[0][pkey.q_tab[1][b1] ^ byte(key[1], 1)] ^ byte(key[0], 1);
+        b2 = pkey.q_tab[1][pkey.q_tab[0][b2] ^ byte(key[1], 2)] ^ byte(key[0], 2);
+        b3 = pkey.q_tab[1][pkey.q_tab[1][b3] ^ byte(key[1], 3)] ^ byte(key[0], 3);      
+    return pkey.m_tab[0][b0] ^ pkey.m_tab[1][b1] ^ pkey.m_tab[2][b2] ^ pkey.m_tab[3][b3];   
+
+def mds_rem(p0, p1):
+    i, t, u = 0, 0, 0
+    for i in range(8):
+        t = p1 >> 24
+        p1 = ((p1 << 8) & 0xffffffff) | (p0 >> 24)
+        p0 = (p0 << 8) & 0xffffffff
+        u = (t << 1) & 0xffffffff
+        if t & 0x80:
+            u ^= 0x0000014d
+        p1 ^= t ^ ((u << 16) & 0xffffffff)
+        u ^= (t >> 1)
+        if t & 0x01:
+            u ^= 0x0000014d >> 1
+        p1 ^= ((u << 24) & 0xffffffff) | ((u << 8) & 0xffffffff)
+    return p1
+
+def set_key(pkey, in_key, key_len):
+    pkey.qt_gen = 0
+    if not pkey.qt_gen:
+        gen_qtab(pkey)
+        pkey.qt_gen = 1
+    pkey.mt_gen = 0
+    if not pkey.mt_gen:
+        gen_mtab(pkey)
+        pkey.mt_gen = 1
+    pkey.k_len = (key_len * 8) // 64
+
+    a = 0
+    b = 0
+    me_key = [0,0,0,0]
+    mo_key = [0,0,0,0]
+    for i in range(pkey.k_len):
+        if WORD_BIGENDIAN:
+            a = byteswap32(in_key[i + 1])
+            me_key[i] = a            
+            b = byteswap32(in_key[i + i + 1])
+        else:
+            a = in_key[i + i]
+            me_key[i] = a            
+            b = in_key[i + i + 1]
+        mo_key[i] = b
+        pkey.s_key[pkey.k_len - i - 1] = mds_rem(a, b);
+    for i in range(0, 40, 2):
+        a = (0x01010101 * i) % 0x100000000;
+        b = (a + 0x01010101) % 0x100000000;
+        a = h_fun(pkey, a, me_key);
+        b = rotl32(h_fun(pkey, b, mo_key), 8);
+        pkey.l_key[i] = (a + b) % 0x100000000;
+        pkey.l_key[i + 1] = rotl32((a + 2 * b) % 0x100000000, 9);
+    gen_mk_tab(pkey, pkey.s_key)
+
+def encrypt(pkey, in_blk):
+    blk = [0, 0, 0, 0]
+
+    if WORD_BIGENDIAN:
+        blk[0] = byteswap32(in_blk[0]) ^ pkey.l_key[0];
+        blk[1] = byteswap32(in_blk[1]) ^ pkey.l_key[1];
+        blk[2] = byteswap32(in_blk[2]) ^ pkey.l_key[2];
+        blk[3] = byteswap32(in_blk[3]) ^ pkey.l_key[3];
+    else:
+        blk[0] = in_blk[0] ^ pkey.l_key[0];
+        blk[1] = in_blk[1] ^ pkey.l_key[1];
+        blk[2] = in_blk[2] ^ pkey.l_key[2];
+        blk[3] = in_blk[3] ^ pkey.l_key[3];        
+
+    for i in range(8):
+        t1 = ( pkey.mk_tab[0][byte(blk[1],3)] ^ pkey.mk_tab[1][byte(blk[1],0)] ^ pkey.mk_tab[2][byte(blk[1],1)] ^ pkey.mk_tab[3][byte(blk[1],2)] ); 
+        t0 = ( pkey.mk_tab[0][byte(blk[0],0)] ^ pkey.mk_tab[1][byte(blk[0],1)] ^ pkey.mk_tab[2][byte(blk[0],2)] ^ pkey.mk_tab[3][byte(blk[0],3)] );
+        
+        blk[2] = rotr32(blk[2] ^ ((t0 + t1 + pkey.l_key[4 * (i) + 8]) % 0x100000000), 1);
+        blk[3] = rotl32(blk[3], 1) ^ ((t0 + 2 * t1 + pkey.l_key[4 * (i) + 9]) % 0x100000000);
+
+        t1 = ( pkey.mk_tab[0][byte(blk[3],3)] ^ pkey.mk_tab[1][byte(blk[3],0)] ^ pkey.mk_tab[2][byte(blk[3],1)] ^ pkey.mk_tab[3][byte(blk[3],2)] ); 
+        t0 = ( pkey.mk_tab[0][byte(blk[2],0)] ^ pkey.mk_tab[1][byte(blk[2],1)] ^ pkey.mk_tab[2][byte(blk[2],2)] ^ pkey.mk_tab[3][byte(blk[2],3)] );
+        
+        blk[0] = rotr32(blk[0] ^ ((t0 + t1 + pkey.l_key[4 * (i) + 10]) % 0x100000000), 1);
+        blk[1] = rotl32(blk[1], 1) ^ ((t0 + 2 * t1 + pkey.l_key[4 * (i) + 11]) % 0x100000000);         
+
+    if WORD_BIGENDIAN:
+        in_blk[0] = byteswap32(blk[2] ^ pkey.l_key[4]);
+        in_blk[1] = byteswap32(blk[3] ^ pkey.l_key[5]);
+        in_blk[2] = byteswap32(blk[0] ^ pkey.l_key[6]);
+        in_blk[3] = byteswap32(blk[1] ^ pkey.l_key[7]);
+    else:
+        in_blk[0] = blk[2] ^ pkey.l_key[4];
+        in_blk[1] = blk[3] ^ pkey.l_key[5];
+        in_blk[2] = blk[0] ^ pkey.l_key[6];
+        in_blk[3] = blk[1] ^ pkey.l_key[7];
+        
+    return
+
+def decrypt(pkey, in_blk):
+    blk = [0, 0, 0, 0]
+    
+    if WORD_BIGENDIAN:
+        blk[0] = byteswap32(in_blk[0]) ^ pkey.l_key[4];
+        blk[1] = byteswap32(in_blk[1]) ^ pkey.l_key[5];
+        blk[2] = byteswap32(in_blk[2]) ^ pkey.l_key[6];
+        blk[3] = byteswap32(in_blk[3]) ^ pkey.l_key[7];
+    else:
+        blk[0] = in_blk[0] ^ pkey.l_key[4];
+        blk[1] = in_blk[1] ^ pkey.l_key[5];
+        blk[2] = in_blk[2] ^ pkey.l_key[6];
+        blk[3] = in_blk[3] ^ pkey.l_key[7];    
+
+    for i in range(7, -1, -1):
+        t1 = ( pkey.mk_tab[0][byte(blk[1],3)] ^ pkey.mk_tab[1][byte(blk[1],0)] ^ pkey.mk_tab[2][byte(blk[1],1)] ^ pkey.mk_tab[3][byte(blk[1],2)] )
+        t0 = ( pkey.mk_tab[0][byte(blk[0],0)] ^ pkey.mk_tab[1][byte(blk[0],1)] ^ pkey.mk_tab[2][byte(blk[0],2)] ^ pkey.mk_tab[3][byte(blk[0],3)] )
+
+        blk[2] = rotl32(blk[2], 1) ^ ((t0 + t1 + pkey.l_key[4 * (i) + 10]) % 0x100000000)
+        blk[3] = rotr32(blk[3] ^ ((t0 + 2 * t1 + pkey.l_key[4 * (i) + 11]) % 0x100000000), 1)
+
+        t1 = ( pkey.mk_tab[0][byte(blk[3],3)] ^ pkey.mk_tab[1][byte(blk[3],0)] ^ pkey.mk_tab[2][byte(blk[3],1)] ^ pkey.mk_tab[3][byte(blk[3],2)] )
+        t0 = ( pkey.mk_tab[0][byte(blk[2],0)] ^ pkey.mk_tab[1][byte(blk[2],1)] ^ pkey.mk_tab[2][byte(blk[2],2)] ^ pkey.mk_tab[3][byte(blk[2],3)] )
+
+        blk[0] = rotl32(blk[0], 1) ^ ((t0 + t1 + pkey.l_key[4 * (i) + 8]) % 0x100000000)
+        blk[1] = rotr32(blk[1] ^ ((t0 + 2 * t1 + pkey.l_key[4 * (i) + 9]) % 0x100000000), 1)        
+
+    if WORD_BIGENDIAN:
+        in_blk[0] = byteswap32(blk[2] ^ pkey.l_key[0]);
+        in_blk[1] = byteswap32(blk[3] ^ pkey.l_key[1]);
+        in_blk[2] = byteswap32(blk[0] ^ pkey.l_key[2]);
+        in_blk[3] = byteswap32(blk[1] ^ pkey.l_key[3]);
+    else:
+        in_blk[0] = blk[2] ^ pkey.l_key[0];
+        in_blk[1] = blk[3] ^ pkey.l_key[1];
+        in_blk[2] = blk[0] ^ pkey.l_key[2];
+        in_blk[3] = blk[1] ^ pkey.l_key[3];
+    return
+
+__testkey = b'\xD4\x3B\xB7\x55\x6E\xA3\x2E\x46\xF2\xA2\x82\xB7\xD4\x5B\x4E\x0D\x57\xFF\x73\x9D\x4D\xC9\x2C\x1B\xD7\xFC\x01\x70\x0C\xC8\x21\x6F'
+__testdat = b'\x90\xAF\xE9\x1B\xB2\x88\x54\x4F\x2C\x32\xDC\x23\x9B\x26\x35\xE6'
+assert b'l\xb4V\x1c@\xbf\n\x97\x05\x93\x1c\xb6\xd4\x08\xe7\xfa' == Twofish(__testkey).encrypt(__testdat)
+assert __testdat == Twofish(__testkey).decrypt(b'l\xb4V\x1c@\xbf\n\x97\x05\x93\x1c\xb6\xd4\x08\xe7\xfa')
+

Decipher/validator.py

@@ -0,0 +1,65 @@
+import ipaddress
+from typing import List, Dict, Set
+from Decipher.models import NetworkTopology
+
+def validate_topology(topology: NetworkTopology) -> List[str]:
+    """
+    Performs logical validation on the network topology and returns a list of warnings/errors.
+    """
+    issues = []
+    device_names = {d.name for d in topology.devices}
+    ip_to_interface = {} # ip -> (device, interface)
+
+    # 1. Check for IP Conflicts and basic interface sanity
+    for device in topology.devices:
+        for intf in device.interfaces:
+            if intf.ip:
+                # Check for duplicate IPs
+                if intf.ip in ip_to_interface:
+                    other_dev, other_intf = ip_to_interface[intf.ip]
+                    issues.append(f"IP Conflict: {intf.ip} is assigned to both {device.name} ({intf.name}) and {other_dev} ({other_intf})")
+                else:
+                    ip_to_interface[intf.ip] = (device.name, intf.name)
+                
+                # Basic IP format validation
+                try:
+                    if "/" in intf.ip:
+                        ipaddress.ip_interface(intf.ip)
+                    else:
+                        ipaddress.ip_address(intf.ip)
+                except ValueError:
+                    issues.append(f"Invalid IP Format: '{intf.ip}' on {device.name} ({intf.name})")
+
+    # 2. Ensure Link Endpoints Exist
+    for link in topology.physical_links:
+        if link.from_device not in device_names:
+            issues.append(f"Broken Link: Source device '{link.from_device}' does not exist.")
+        if link.to_device not in device_names:
+            issues.append(f"Broken Link: Destination device '{link.to_device}' does not exist.")
+
+    # 3. Verify Routing Protocols (Basic Sanity)
+    for device in topology.devices:
+        if device.routing and device.routing.ospf:
+            device_ips = [intf.ip for intf in device.interfaces if intf.ip]
+            for ospf in device.routing.ospf:
+                for net_statement in ospf.networks:
+                    # Check if the OSPF network statement matches at least one interface IP segment
+                    try:
+                        # network statement is usually "network 10.0.0.0 0.0.0.255 area 0"
+                        # we extract the network and wildcard mask
+                        parts = net_statement.split()
+                        if "network" in parts:
+                            net_addr = parts[parts.index("network") + 1]
+                            # Simple check: does any device IP start with the same prefix?
+                            # This is a heuristic check
+                            found_match = False
+                            for ip in device_ips:
+                                if ip.split('.')[0:2] == net_addr.split('.')[0:2]:
+                                    found_match = True
+                                    break
+                            if not found_match:
+                                issues.append(f"OSPF Warning: Network statement '{net_statement}' on {device.name} doesn't seem to match any local interface IPs.")
+                    except Exception:
+                        pass
+
+    return issues

Dockerfile

@@ -0,0 +1,25 @@
+# Use an official Python runtime as a parent image
+FROM python:3.13-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Install system dependencies if any (none needed for now)
+# RUN apt-get update && apt-get install -y --no-install-recommends \
+#     build-essential \
+#     && rm -rf /var/lib/apt/lists/*
+
+# Copy the requirements file into the container
+COPY requirements.txt .
+
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the current directory contents into the container at /app
+COPY . .
+
+# Hugging Face Spaces uses port 7860 by default
+ENV PORT=7860
+
+# Run the application
+CMD ["python", "main.py"]

main.py

@@ -0,0 +1,80 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+import os
+import shutil
+import tempfile
+import xml.etree.ElementTree as ET
+from Decipher.pt_crypto import decrypt_pkt
+from Decipher.extract import extract_structured_data
+from Decipher.generator import generate_network
+from Decipher.models import NetworkTopology
+from pydantic import Field, BaseModel
+
+class PromptRequest(BaseModel):
+    prompt: str = Field(..., description="The description of the network to generate", json_schema_extra={"example": "A network with 1 router and 2 PCs"})
+
+app = FastAPI(title="TopoScan API", description="API for decrypting and extracting data from Cisco Packet Tracer files")
+
+# Enable CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/")
+async def root():
+    return {"message": "TopoScan API is running"}
+
+@app.post("/analyze-pkt")
+async def analyze_pkt(file: UploadFile = File(...)):
+    if not file.filename.endswith(".pkt") and not file.filename.endswith(".pka"):
+        raise HTTPException(status_code=400, detail="Only .pkt or .pka files are supported")
+
+    try:
+        # Read the uploaded file content
+        content = await file.read()
+        
+        # Decrypt the file
+        try:
+            xml_data = decrypt_pkt(content)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Decryption failed: {str(e)}")
+
+        # Create a temporary file to store the XML for extraction
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".xml") as temp_xml:
+            temp_xml.write(xml_data)
+            temp_xml_path = temp_xml.name
+
+        try:
+            # Extract structured data using existing logic
+            structured_data = extract_structured_data(temp_xml_path)
+            
+            if structured_data is None:
+                raise HTTPException(status_code=500, detail="Failed to extract structured data from decrypted XML")
+            
+            return structured_data
+            
+        finally:
+            # Clean up the temporary file
+            if os.path.exists(temp_xml_path):
+                os.remove(temp_xml_path)
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
+
+@app.post("/generate-network", response_model=NetworkTopology)
+async def api_generate_network(request: PromptRequest):
+    try:
+        topology = generate_network(request.prompt)
+        return topology
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Generation failed: {str(e)}")
+
+if __name__ == "__main__":
+    import uvicorn
+    # Hugging Face Spaces and other cloud providers often use the PORT environment variable
+    port = int(os.environ.get("PORT", 8000))
+    uvicorn.run(app, host="0.0.0.0", port=port)

requirements.txt

@@ -0,0 +1,8 @@
+fastapi==0.128.3
+uvicorn==0.40.0
+pydantic==2.12.5
+python-dotenv==1.2.1
+openai==2.36.0
+ciscoconfparse==1.9.52
+python-multipart==0.0.22
+requests==2.32.5