mcpcap 0.3.2__py3-none-any.whl → 0.4.1__py3-none-any.whl

mcpcap/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.2'
-__version_tuple__ = version_tuple = (0, 3, 2)
+__version__ = version = '0.4.1'
+__version_tuple__ = version_tuple = (0, 4, 1)
 
 __commit_id__ = commit_id = None

mcpcap/cli.py

@@ -42,11 +42,6 @@ def main():
         help="Comma-separated list of modules to load (default: dns)",
         default="dns",
     )
-    parser.add_argument(
-        "--protocols",
-        help="Comma-separated list of protocols to analyze (default: dns)",
-        default="dns",
-    )
     parser.add_argument(
         "--max-packets",
         type=int,
@@ -56,12 +51,16 @@ def main():
     args = parser.parse_args()
 
     try:
+        # Parse modules and automatically set protocols to match
+        modules = args.modules.split(",") if args.modules else ["dns"]
+        protocols = modules  # Protocols automatically match loaded modules
+
         # Initialize configuration
         config = Config(
             pcap_path=args.pcap_path,
             pcap_url=args.pcap_url,
-            modules=args.modules.split(",") if args.modules else ["dns"],
-            protocols=args.protocols.split(",") if args.protocols else ["dns"],
+            modules=modules,
+            protocols=protocols,
             max_packets=args.max_packets,
         )
 

mcpcap/core/server.py

@@ -2,6 +2,7 @@
 
 from fastmcp import FastMCP
 
+from ..modules.dhcp import DHCPModule
 from ..modules.dns import DNSModule
 from .config import Config
 
@@ -18,20 +19,34 @@ class MCPServer:
         self.config = config
         self.mcp = FastMCP("mcpcap")
 
-        # Initialize modules
-        self.dns_module = DNSModule(config)
+        # Initialize modules based on configuration
+        self.modules = {}
+        if "dns" in self.config.modules:
+            self.modules["dns"] = DNSModule(config)
+        if "dhcp" in self.config.modules:
+            self.modules["dhcp"] = DHCPModule(config)
 
         # Register tools
         self._register_tools()
 
         # Setup prompts
-        self.dns_module.setup_prompts(self.mcp)
+        for module in self.modules.values():
+            module.setup_prompts(self.mcp)
 
     def _register_tools(self) -> None:
         """Register all available tools with the MCP server."""
-        # Register DNS module tools
-        self.mcp.tool(self.dns_module.list_dns_packets)
-        self.mcp.tool(self.dns_module.list_pcap_files)
+        # Register tools for each loaded module
+        for module_name, module in self.modules.items():
+            if module_name == "dns":
+                self.mcp.tool(module.list_dns_packets)
+            elif module_name == "dhcp":
+                self.mcp.tool(module.list_dhcp_packets)
+
+        # Register shared list_pcap_files tool (same for all modules)
+        if self.modules:
+            # Use the first available module for listing PCAP files
+            first_module = next(iter(self.modules.values()))
+            self.mcp.tool(first_module.list_pcap_files)
 
     def run(self) -> None:
         """Start the MCP server."""

mcpcap/modules/__init__.py

@@ -1,6 +1,7 @@
 """Protocol analysis modules for mcpcap."""
 
 from .base import BaseModule
+from .dhcp import DHCPModule
 from .dns import DNSModule
 
-__all__ = ["BaseModule", "DNSModule"]
+__all__ = ["BaseModule", "DHCPModule", "DNSModule"]

mcpcap/modules/dhcp.py

@@ -0,0 +1,446 @@
+"""DHCP analysis module."""
+
+import os
+import tempfile
+from typing import Any
+
+from fastmcp import FastMCP
+from scapy.all import BOOTP, DHCP, IP, UDP, rdpcap
+
+from .base import BaseModule
+
+
+class DHCPModule(BaseModule):
+    """Module for analyzing DHCP packets in PCAP files."""
+
+    @property
+    def protocol_name(self) -> str:
+        """Return the name of the protocol this module analyzes."""
+        return "DHCP"
+
+    def list_dhcp_packets(self, pcap_file: str = "") -> dict[str, Any]:
+        """
+        Analyze DHCP packets from a PCAP file and return a summary of each packet.
+
+        Args:
+            pcap_file: Path to the PCAP file to analyze. Leave empty for direct URL remotes
+                      or when using the first available file in local directories.
+
+        Returns:
+            A structured dictionary containing DHCP packet analysis results
+        """
+        # Handle remote files
+        if self.config.is_remote:
+            # For direct file URLs, always use the URL file (ignore pcap_file parameter)
+            if self.config.is_direct_file_url:
+                available_files = self.config.list_pcap_files()
+                if not available_files:
+                    return {
+                        "error": "No PCAP file found at the provided URL",
+                        "pcap_url": self.config.pcap_url,
+                    }
+                pcap_file = available_files[0]  # Use the actual filename from URL
+            elif not pcap_file:
+                # For directory URLs, if no file specified, use the first available
+                available_files = self.config.list_pcap_files()
+                if not available_files:
+                    return {
+                        "error": "No PCAP files found at the provided URL",
+                        "pcap_url": self.config.pcap_url,
+                        "available_files": [],
+                    }
+                pcap_file = available_files[0]
+
+            # Download remote file to temporary location
+            try:
+                with tempfile.NamedTemporaryFile(
+                    suffix=".pcap", delete=False
+                ) as tmp_file:
+                    temp_path = tmp_file.name
+
+                local_path = self.config.download_pcap_file(pcap_file, temp_path)
+                result = self.analyze_packets(local_path)
+
+                # Clean up temporary file
+                try:
+                    os.unlink(local_path)
+                except OSError:
+                    pass  # Ignore cleanup errors
+
+                return result
+
+            except Exception as e:
+                # List available PCAP files for help
+                available_files = self.config.list_pcap_files()
+                return {
+                    "error": f"Failed to download PCAP file '{pcap_file}': {str(e)}",
+                    "pcap_url": self.config.pcap_url,
+                    "available_files": available_files,
+                }
+
+        else:
+            # Handle local files
+            if not pcap_file:
+                # If no file specified, use the first available file
+                available_files = self.config.list_pcap_files()
+                if not available_files:
+                    return {
+                        "error": "No PCAP files found in directory",
+                        "pcap_directory": self.config.pcap_path,
+                        "available_files": [],
+                    }
+                pcap_file = available_files[0]
+
+            full_path = self.config.get_pcap_file_path(pcap_file)
+
+            # Check if local file exists
+            if not os.path.exists(full_path):
+                available_files = self.config.list_pcap_files()
+                return {
+                    "error": f"PCAP file '{pcap_file}' not found",
+                    "file_path": full_path,
+                    "available_files": available_files,
+                    "pcap_directory": self.config.pcap_path,
+                }
+
+            return self.analyze_packets(full_path)
+
+    def list_pcap_files(self) -> str:
+        """
+        List all available PCAP files in the configured directory or remote URL.
+
+        Returns:
+            A list of available PCAP files that can be analyzed
+        """
+        files = self.config.list_pcap_files()
+        source = (
+            self.config.pcap_url if self.config.is_remote else self.config.pcap_path
+        )
+
+        if files:
+            if self.config.is_remote and self.config.is_direct_file_url:
+                return f"Direct PCAP file URL: {source}\\n- {files[0]}"
+            elif not self.config.is_remote and self.config.is_direct_file_path:
+                return f"Direct PCAP file path: {source}\\n- {files[0]}"
+            else:
+                source_type = "remote server" if self.config.is_remote else "directory"
+                return (
+                    f"Available PCAP files in {source_type} {source}:\\n"
+                    + "\\n".join(f"- {f}" for f in sorted(files))
+                )
+        else:
+            source_type = "remote server" if self.config.is_remote else "directory"
+            return f"No PCAP files found in {source_type} {source}"
+
+    def analyze_packets(self, pcap_file: str) -> dict[str, Any]:
+        """Analyze DHCP packets in a PCAP file.
+
+        Args:
+            pcap_file: Path to the PCAP file to analyze
+
+        Returns:
+            Dictionary containing DHCP packet analysis results
+        """
+        try:
+            packets = rdpcap(pcap_file)
+            dhcp_packets = [pkt for pkt in packets if pkt.haslayer(BOOTP)]
+
+            if not dhcp_packets:
+                return {
+                    "file": pcap_file,
+                    "total_packets": len(packets),
+                    "dhcp_packets_found": 0,
+                    "message": "No DHCP packets found in this capture",
+                }
+
+            # Apply max_packets limit if specified
+            packets_to_analyze = dhcp_packets
+            limited = False
+            if self.config.max_packets and len(dhcp_packets) > self.config.max_packets:
+                packets_to_analyze = dhcp_packets[: self.config.max_packets]
+                limited = True
+
+            packet_details = []
+            for i, pkt in enumerate(packets_to_analyze, 1):
+                packet_info = self._analyze_dhcp_packet(pkt, i)
+                packet_details.append(packet_info)
+
+            # Generate statistics
+            stats = self._generate_statistics(packet_details)
+
+            result = {
+                "file": pcap_file,
+                "total_packets": len(packets),
+                "dhcp_packets_found": len(dhcp_packets),
+                "dhcp_packets_analyzed": len(packet_details),
+                "statistics": stats,
+                "packets": packet_details,
+            }
+
+            # Add information about packet limiting
+            if limited:
+                result["note"] = (
+                    f"Analysis limited to first {self.config.max_packets} DHCP packets due to --max-packets setting"
+                )
+
+            return result
+
+        except Exception as e:
+            return {
+                "error": f"Error reading PCAP file '{pcap_file}': {str(e)}",
+                "file": pcap_file,
+            }
+
+    def _analyze_dhcp_packet(self, packet, packet_num: int) -> dict[str, Any]:
+        """Analyze a single DHCP packet and extract relevant information."""
+        info = {
+            "packet_number": packet_num,
+            "timestamp": packet.time,
+        }
+
+        # Basic IP information
+        if packet.haslayer(IP):
+            ip_layer = packet[IP]
+            info.update(
+                {
+                    "src_ip": ip_layer.src,
+                    "dst_ip": ip_layer.dst,
+                }
+            )
+
+        # UDP information
+        if packet.haslayer(UDP):
+            udp_layer = packet[UDP]
+            info.update(
+                {
+                    "src_port": udp_layer.sport,
+                    "dst_port": udp_layer.dport,
+                }
+            )
+
+        # BOOTP/DHCP information
+        if packet.haslayer(BOOTP):
+            bootp_layer = packet[BOOTP]
+            info.update(
+                {
+                    "op": "Request" if bootp_layer.op == 1 else "Reply",
+                    "transaction_id": f"0x{bootp_layer.xid:08x}",
+                    "client_ip": str(bootp_layer.ciaddr),
+                    "your_ip": str(bootp_layer.yiaddr),
+                    "server_ip": str(bootp_layer.siaddr),
+                    "relay_ip": str(bootp_layer.giaddr),
+                    "client_mac": bootp_layer.chaddr[:6].hex(":"),
+                }
+            )
+
+        # DHCP options analysis
+        if packet.haslayer(DHCP):
+            dhcp_layer = packet[DHCP]
+            dhcp_info = self._parse_dhcp_options(dhcp_layer.options)
+            info.update(dhcp_info)
+
+        return info
+
+    def _parse_dhcp_options(self, options) -> dict[str, Any]:
+        """Parse DHCP options and return structured information."""
+        dhcp_info = {"options": {}}
+
+        # DHCP message type mappings
+        message_types = {
+            1: "DISCOVER",
+            2: "OFFER",
+            3: "REQUEST",
+            4: "DECLINE",
+            5: "ACK",
+            6: "NAK",
+            7: "RELEASE",
+            8: "INFORM",
+        }
+
+        for opt in options:
+            if isinstance(opt, tuple) and len(opt) == 2:
+                key, value = opt
+
+                if key == "message-type":
+                    dhcp_info["message_type"] = message_types.get(
+                        value, f"Unknown({value})"
+                    )
+                    dhcp_info["message_type_code"] = value
+                elif key == "lease_time":
+                    dhcp_info["lease_time"] = value
+                    dhcp_info["options"]["lease_time"] = f"{value} seconds"
+                elif key == "renewal_time":
+                    dhcp_info["renewal_time"] = value
+                    dhcp_info["options"]["renewal_time"] = f"{value} seconds"
+                elif key == "rebinding_time":
+                    dhcp_info["rebinding_time"] = value
+                    dhcp_info["options"]["rebinding_time"] = f"{value} seconds"
+                elif key == "server_id":
+                    dhcp_info["server_id"] = str(value)
+                elif key == "subnet_mask":
+                    dhcp_info["options"]["subnet_mask"] = str(value)
+                elif key == "router":
+                    dhcp_info["options"]["router"] = str(value)
+                elif key == "name_server":
+                    dhcp_info["options"]["dns_servers"] = str(value)
+                elif key == "requested_addr":
+                    dhcp_info["requested_ip"] = str(value)
+                elif key == "client_id":
+                    if isinstance(value, bytes):
+                        dhcp_info["client_id"] = value.hex(":")
+                    else:
+                        dhcp_info["client_id"] = str(value)
+                elif key == "param_req_list":
+                    dhcp_info["options"]["parameter_request_list"] = list(value)
+                else:
+                    # Store other options as strings
+                    dhcp_info["options"][key] = str(value)
+
+        return dhcp_info
+
+    def _generate_statistics(self, packets: list[dict[str, Any]]) -> dict[str, Any]:
+        """Generate statistics from analyzed DHCP packets."""
+        stats = {
+            "unique_clients": set(),
+            "unique_servers": set(),
+            "message_types": {},
+            "transactions": {},
+        }
+
+        for pkt in packets:
+            # Count unique clients and servers
+            if "client_mac" in pkt:
+                stats["unique_clients"].add(pkt["client_mac"])
+            if "server_id" in pkt:
+                stats["unique_servers"].add(pkt["server_id"])
+
+            # Count message types
+            if "message_type" in pkt:
+                msg_type = pkt["message_type"]
+                stats["message_types"][msg_type] = (
+                    stats["message_types"].get(msg_type, 0) + 1
+                )
+
+            # Track transactions
+            if "transaction_id" in pkt:
+                tx_id = pkt["transaction_id"]
+                if tx_id not in stats["transactions"]:
+                    stats["transactions"][tx_id] = []
+                stats["transactions"][tx_id].append(
+                    {
+                        "packet_number": pkt["packet_number"],
+                        "message_type": pkt.get("message_type", "Unknown"),
+                        "timestamp": pkt["timestamp"],
+                    }
+                )
+
+        # Convert sets to counts for JSON serialization
+        return {
+            "unique_clients_count": len(stats["unique_clients"]),
+            "unique_servers_count": len(stats["unique_servers"]),
+            "unique_clients": list(stats["unique_clients"]),
+            "unique_servers": list(stats["unique_servers"]),
+            "message_type_counts": stats["message_types"],
+            "transaction_count": len(stats["transactions"]),
+            "transactions": stats["transactions"],
+        }
+
+    def setup_prompts(self, mcp: FastMCP) -> None:
+        """Set up DHCP-specific analysis prompts for the MCP server.
+
+        Args:
+            mcp: FastMCP server instance
+        """
+
+        @mcp.prompt
+        def dhcp_network_analysis():
+            """Prompt for analyzing DHCP traffic from a network perspective"""
+            return """You are a network administrator analyzing DHCP traffic. Focus your analysis on:
+
+1. **IP Address Management:**
+   - Track DHCP lease assignments and renewals
+   - Identify IP address pool usage and availability
+   - Look for lease conflicts or duplicate IP assignments
+   - Monitor lease duration patterns and optimization
+
+2. **Client Behavior Analysis:**
+   - Identify DHCP client types and operating systems
+   - Track client renewal patterns and timing
+   - Look for unusual client behavior (rapid requests, failures)
+   - Monitor mobile devices vs. static clients
+
+3. **Server Performance:**
+   - Analyze DHCP server response times
+   - Look for server failures or timeouts
+   - Check for multiple DHCP servers (potential conflicts)
+   - Monitor server load and capacity planning
+
+4. **Network Troubleshooting:**
+   - Identify DHCP DISCOVER floods or storms
+   - Look for relay agent issues
+   - Check for scope exhaustion problems
+   - Find misconfigurations in options delivery
+
+Provide specific recommendations for network optimization and problem resolution."""
+
+        @mcp.prompt
+        def dhcp_security_analysis():
+            """Prompt for analyzing DHCP traffic from a security perspective"""
+            return """You are a security analyst examining DHCP traffic for threats. Focus on:
+
+1. **Rogue DHCP Detection:**
+   - Identify unauthorized DHCP servers on the network
+   - Look for conflicting server responses or options
+   - Check for suspicious server_id values
+   - Monitor for DHCP server impersonation attempts
+
+2. **DHCP Attacks:**
+   - Detect DHCP starvation attacks (rapid lease consumption)
+   - Look for DHCP spoofing or man-in-the-middle attempts
+   - Identify abnormal request patterns or frequencies
+   - Check for MAC address spoofing in client requests
+
+3. **Client Anomalies:**
+   - Find clients with suspicious hostnames or identifiers
+   - Look for rapid MAC address changes from single sources
+   - Detect clients requesting unusual or dangerous options
+   - Monitor for clients bypassing expected DHCP flow
+
+4. **Data Exfiltration Risks:**
+   - Check for unusual data in DHCP option fields
+   - Look for DNS server redirection attempts
+   - Monitor for suspicious router or gateway assignments
+   - Identify potential DNS tunneling via DHCP options
+
+Provide threat assessment and recommended security controls."""
+
+        @mcp.prompt
+        def dhcp_forensic_investigation():
+            """Prompt for forensic analysis of DHCP traffic"""
+            return """You are conducting a digital forensics investigation involving DHCP traffic. Approach systematically:
+
+1. **Timeline Reconstruction:**
+   - Create chronological sequence of DHCP transactions
+   - Map client activity periods and network presence
+   - Correlate DHCP assignments with incident timeframes
+   - Track device mobility through IP address changes
+
+2. **Device Attribution:**
+   - Link MAC addresses to specific devices or users
+   - Track device behavior patterns across time
+   - Identify device types through DHCP fingerprinting
+   - Document lease history for evidence correlation
+
+3. **Network Mapping:**
+   - Reconstruct network topology from DHCP data
+   - Identify network segments and VLAN assignments
+   - Map DHCP server infrastructure and relationships
+   - Document network configuration at incident time
+
+4. **Evidence Collection:**
+   - Extract client identifiers and hostnames
+   - Document IP address assignments for legal proceedings
+   - Preserve transaction timing for event correlation
+   - Collect option data that may contain forensic artifacts
+
+Present findings with precise timestamps, evidence preservation notes, and clear documentation suitable for legal proceedings."""

{mcpcap-0.3.2.dist-info → mcpcap-0.4.1.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: mcpcap
-Version: 0.3.2
+Version: 0.4.1
 Summary: A modular Python MCP Server for analyzing PCAP files
 Author: mcpcap contributors
 License: MIT
-Project-URL: Homepage, https://github.com/danohn/mcpcap
-Project-URL: Repository, https://github.com/danohn/mcpcap
-Project-URL: Issues, https://github.com/danohn/mcpcap/issues
+Project-URL: Homepage, https://github.com/mcpcap/mcpcap
+Project-URL: Repository, https://github.com/mcpcap/mcpcap
+Project-URL: Issues, https://github.com/mcpcap/mcpcap/issues
 Keywords: pcap,network,analysis,mcp,dns
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -44,7 +44,7 @@ Dynamic: license-file
 
 # mcpcap
 
-![mcpcap logo](https://raw.githubusercontent.com/danohn/mcpcap/main/readme-assets/mcpcap-logo.png)
+![mcpcap logo](https://raw.githubusercontent.com/mcpcap/mcpcap/main/readme-assets/mcpcap-logo.png)
 
 A modular Python MCP (Model Context Protocol) Server for analyzing PCAP files. mcpcap enables LLMs to read and analyze network packet captures from local or remote sources, providing structured JSON responses about network traffic.
 
@@ -115,6 +115,8 @@ uvx mcpcap
 
 ## Modules
 
+mcpcap supports multiple protocol analysis modules:
+
 ### DNS Module
 
 The DNS module analyzes Domain Name System packets in PCAP files.
@@ -127,11 +129,26 @@ The DNS module analyzes Domain Name System packets in PCAP files.
 - Track query frequency and patterns
 - Identify DNS servers used
 
+### DHCP Module
+
+The DHCP module analyzes Dynamic Host Configuration Protocol packets in PCAP files.
+
+**Capabilities**:
+
+- Track DHCP transactions (DISCOVER, OFFER, REQUEST, ACK)
+- Identify DHCP clients and servers
+- Monitor IP address assignments and lease information
+- Analyze DHCP options and configurations
+- Detect DHCP anomalies and security issues
+
 **Example Usage**:
 
-```python
-# LLM can ask: "What domains were queried in this PCAP?"
-# mcpcap will return structured JSON with DNS query information
+```bash
+# Analyze DHCP traffic only
+mcpcap --pcap-path /path/to/dhcp.pcap --modules dhcp
+
+# Analyze both DNS and DHCP
+mcpcap --pcap-path /path/to/mixed.pcap --modules dns,dhcp
 ```
 
 ## Configuration
@@ -164,12 +181,23 @@ mcpcap --pcap-url http://example.com/pcaps/
 
 **Module Selection**:
 ```bash
+# Single module
 mcpcap --modules dns --pcap-path /path/to/files
+
+# Multiple modules
+mcpcap --modules dns,dhcp --pcap-path /path/to/files
 ```
 
-**Protocol Filtering**:
+**Protocol Selection** (automatically matches loaded modules):
 ```bash
-mcpcap --protocols dns --pcap-path /path/to/files
+# DNS analysis only
+mcpcap --modules dns --pcap-path /path/to/files
+
+# DHCP analysis only  
+mcpcap --modules dhcp --pcap-path /path/to/files
+
+# Both DNS and DHCP analysis
+mcpcap --modules dns,dhcp --pcap-path /path/to/files
 ```
 
 **Packet Limiting** (for large files):
@@ -179,7 +207,7 @@ mcpcap --max-packets 1000 --pcap-path /path/to/files
 
 **Combined Options**:
 ```bash
-mcpcap --pcap-path /data/capture.pcap --max-packets 500 --protocols dns
+mcpcap --pcap-path /data/capture.pcap --max-packets 500 --modules dns,dhcp
 ```
 
 ## CLI Reference
@@ -194,7 +222,8 @@ mcpcap [--pcap-path PATH | --pcap-url URL] [OPTIONS]
 
 **Analysis Options**:
 - `--modules MODULES`: Comma-separated modules to load (default: dns)
-- `--protocols PROTOCOLS`: Comma-separated protocols to analyze (default: dns) 
+  - Available modules: `dns`, `dhcp`
+  - Protocols are automatically set to match loaded modules
 - `--max-packets N`: Maximum packets to analyze per file (default: unlimited)
 
 **Examples**:
@@ -205,8 +234,8 @@ mcpcap --pcap-path ./capture.pcap
 # Remote file with packet limit
 mcpcap --pcap-url https://example.com/dns.cap --max-packets 100
 
-# Directory with protocol filter
-mcpcap --pcap-path /captures --protocols dns --modules dns
+# Directory with DHCP analysis
+mcpcap --pcap-path /captures --modules dhcp
 ```
 
 ## Example
@@ -284,6 +313,10 @@ MIT
 - fastmcp (MCP server framework)
 - All dependencies are automatically installed via pip
 
+## Documentation
+
+Full documentation is available at [docs.mcpcap.ai](https://docs.mcpcap.ai)
+
 ## Support
 
 For questions, issues, or feature requests, please open an issue on GitHub.

mcpcap-0.4.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+mcpcap/__init__.py,sha256=rJwCpBXkhIvmsqHFpeR33Vg8kuipNPJ2JdlAjsTk7I4,1408
+mcpcap/_version.py,sha256=k7cu0JKra64gmMNU_UfA5sw2eNc_GRvf3QmesiYAy8g,704
+mcpcap/cli.py,sha256=nsHg-c72BrJaIUiVPoj-JWahQu8k0ldxYmWzbnljEBk,2448
+mcpcap/core/__init__.py,sha256=WM5GTl06ZwwqHTPiKaYB-9hwOOXe3hyHG16FshwSsjE,127
+mcpcap/core/config.py,sha256=WdHYu14Cvn9C3xs3KsQ-SVRru00IH86nQfnDL57V9zE,8190
+mcpcap/core/server.py,sha256=H2ttfokMzW3vICxjCOFCoQTe78HHs-bGUxMd6i7rE1k,2011
+mcpcap/modules/__init__.py,sha256=kA91h_-f7RE7pvEgcsQTZigDptK5v17-mbqTXZTRTK8,183
+mcpcap/modules/base.py,sha256=3h8lGt6d6ob4SbgP6THC5PnTeMRcKfTGoJ9ZlZsQje0,826
+mcpcap/modules/dhcp.py,sha256=3t9_2Tci5ZKhJlSMfgFbgCg44l5-0FKefAWoDZ_sY-Y,17251
+mcpcap/modules/dns.py,sha256=cc77RxJOf-JxTLTCY8kfc_64uMawWKB3rjme9Q5H1pI,16632
+mcpcap-0.4.1.dist-info/licenses/LICENSE,sha256=Ltj0zxftQyBYQMNva935v0i5QXQQOF8ygE8dQxGEtjk,1063
+mcpcap-0.4.1.dist-info/METADATA,sha256=db8XtdJfxCA9rMnhx6Vs9ogy-4TxN7N40kie3l1HbUo,8709
+mcpcap-0.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcpcap-0.4.1.dist-info/entry_points.txt,sha256=ck69gPBEopmU6mzQy9P6o6ssMr89bQbrvv51IaJ50Gc,39
+mcpcap-0.4.1.dist-info/top_level.txt,sha256=YkRkVGjuM3nI7cVB1l8zIAeqiS_5_vrzbUcHNkH3OXE,7
+mcpcap-0.4.1.dist-info/RECORD,,

mcpcap-0.3.2.dist-info/RECORD

@@ -1,15 +0,0 @@
-mcpcap/__init__.py,sha256=rJwCpBXkhIvmsqHFpeR33Vg8kuipNPJ2JdlAjsTk7I4,1408
-mcpcap/_version.py,sha256=e8NqPtZ8fggRgk3GPrqZ_U_BDV8aSULw1u_Gn9NNbnk,704
-mcpcap/cli.py,sha256=DflEb7i2ATn9lBx4rK43Qpf-aQjKhwSqT20BofzVrFs,2480
-mcpcap/core/__init__.py,sha256=WM5GTl06ZwwqHTPiKaYB-9hwOOXe3hyHG16FshwSsjE,127
-mcpcap/core/config.py,sha256=WdHYu14Cvn9C3xs3KsQ-SVRru00IH86nQfnDL57V9zE,8190
-mcpcap/core/server.py,sha256=BrLgT-zsa2uFQ2B_bNSSrCFID3xXruinnnfRrHo1GKs,1312
-mcpcap/modules/__init__.py,sha256=iIeoZuLA-EOv0OS8WU8qDCitXJnarq9F0hA5-Y97zis,140
-mcpcap/modules/base.py,sha256=3h8lGt6d6ob4SbgP6THC5PnTeMRcKfTGoJ9ZlZsQje0,826
-mcpcap/modules/dns.py,sha256=cc77RxJOf-JxTLTCY8kfc_64uMawWKB3rjme9Q5H1pI,16632
-mcpcap-0.3.2.dist-info/licenses/LICENSE,sha256=Ltj0zxftQyBYQMNva935v0i5QXQQOF8ygE8dQxGEtjk,1063
-mcpcap-0.3.2.dist-info/METADATA,sha256=HeumLFw2sguQyc3FFkP9cGr6ne8Rg513YuVEWziYxJs,7854
-mcpcap-0.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcpcap-0.3.2.dist-info/entry_points.txt,sha256=ck69gPBEopmU6mzQy9P6o6ssMr89bQbrvv51IaJ50Gc,39
-mcpcap-0.3.2.dist-info/top_level.txt,sha256=YkRkVGjuM3nI7cVB1l8zIAeqiS_5_vrzbUcHNkH3OXE,7
-mcpcap-0.3.2.dist-info/RECORD,,