mcpcap 0.3.1__py3-none-any.whl → 0.4.0__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.1'
-__version_tuple__ = version_tuple = (0, 3, 1)
+__version__ = version = '0.4.0'
+__version_tuple__ = version_tuple = (0, 4, 0)
 
 __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.1.dist-info → mcpcap-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcpcap
-Version: 0.3.1
+Version: 0.4.0
 Summary: A modular Python MCP Server for analyzing PCAP files
 Author: mcpcap contributors
 License: MIT
@@ -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

mcpcap-0.4.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+mcpcap/__init__.py,sha256=rJwCpBXkhIvmsqHFpeR33Vg8kuipNPJ2JdlAjsTk7I4,1408
+mcpcap/_version.py,sha256=2_0GUP7yBCXRus-qiJKxQD62z172WSs1sQ6DVpPsbmM,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.0.dist-info/licenses/LICENSE,sha256=Ltj0zxftQyBYQMNva935v0i5QXQQOF8ygE8dQxGEtjk,1063
+mcpcap-0.4.0.dist-info/METADATA,sha256=r_YjdfhT8soaAhLvS23nkEqp4c9_T0InXaFiM5YWKfc,8614
+mcpcap-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcpcap-0.4.0.dist-info/entry_points.txt,sha256=ck69gPBEopmU6mzQy9P6o6ssMr89bQbrvv51IaJ50Gc,39
+mcpcap-0.4.0.dist-info/top_level.txt,sha256=YkRkVGjuM3nI7cVB1l8zIAeqiS_5_vrzbUcHNkH3OXE,7
+mcpcap-0.4.0.dist-info/RECORD,,

mcpcap-0.3.1.dist-info/RECORD

@@ -1,15 +0,0 @@
-mcpcap/__init__.py,sha256=rJwCpBXkhIvmsqHFpeR33Vg8kuipNPJ2JdlAjsTk7I4,1408
-mcpcap/_version.py,sha256=gGLpQUQx-ty9SEy9PYw9OgJWWzJLBnCpfJOfzL7SjlI,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.1.dist-info/licenses/LICENSE,sha256=Ltj0zxftQyBYQMNva935v0i5QXQQOF8ygE8dQxGEtjk,1063
-mcpcap-0.3.1.dist-info/METADATA,sha256=GCTSg601dKs06-KMnD6IqwSqXSubYSdYbsLY_eUVxhA,7854
-mcpcap-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcpcap-0.3.1.dist-info/entry_points.txt,sha256=ck69gPBEopmU6mzQy9P6o6ssMr89bQbrvv51IaJ50Gc,39
-mcpcap-0.3.1.dist-info/top_level.txt,sha256=YkRkVGjuM3nI7cVB1l8zIAeqiS_5_vrzbUcHNkH3OXE,7
-mcpcap-0.3.1.dist-info/RECORD,,