# VLAN Segmentation Example
vlans = {
    'management': {
        'vlan_id': 10,
        'subnet': '10.10.10.0/24',
        'access': 'admin_only',
        'security_level': 'high'
    },
    'servers': {
        'vlan_id': 20,
        'subnet': '10.20.20.0/24',
        'access': 'controlled',
        'security_level': 'high'
    },
    'user_network': {
        'vlan_id': 30,
        'subnet': '10.30.30.0/24',
        'access': 'standard',
        'security_level': 'medium'
    },
    'guest_network': {
        'vlan_id': 40,
        'subnet': '172.16.1.0/24',
        'access': 'internet_only',
        'security_level': 'low'
    },
    'iot_devices': {
        'vlan_id': 50,
        'subnet': '192.168.50.0/24',
        'access': 'isolated',
        'security_level': 'medium'
    }
}

# wireshark_analysis.py
import pyshark

def analyze_suspicious_traffic(pcap_file):
    cap = pyshark.FileCapture(pcap_file, display_filter='tcp.flags.reset==1')
    
    suspicious_ips = {}
    
    for packet in cap:
        try:
            src_ip = packet.ip.src
            dst_ip = packet.ip.dst
            
            if src_ip not in suspicious_ips:
                suspicious_ips[src_ip] = {'reset_count': 0, 'targets': set()}
            
            suspicious_ips[src_ip]['reset_count'] += 1
            suspicious_ips[src_ip]['targets'].add(dst_ip)
            
        except AttributeError:
            continue
    
    # Report IPs with high reset count (possible port scanning)
    for ip, data in suspicious_ips.items():
        if data['reset_count'] > 50:  # Threshold
            print(f"SUSPICIOUS: {ip} sent {data['reset_count']} RST packets to {len(data['targets'])} targets")

if __name__ == "__main__":
    analyze_suspicious_traffic("suspicious_traffic.pcap")

# network_backup.py
import paramiko
import schedule
import time
from datetime import datetime

class NetworkBackup:
    def __init__(self, devices):
        self.devices = devices
        
    def backup_cisco_device(self, device):
        try:
            ssh = paramiko.SSHClient()
            ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
            ssh.connect(
                device['ip'], 
                username=device['username'], 
                password=device['password']
            )
            
            # Execute show running-config
            stdin, stdout, stderr = ssh.exec_command('show running-config')
            config = stdout.read().decode()
            
            # Save configuration
            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
            filename = f"backup_{device['hostname']}_{timestamp}.txt"
            
            with open(f"/backup/{filename}", 'w') as f:
                f.write(config)
                
            ssh.close()
            print(f"Backup completed for {device['hostname']}")
            
        except Exception as e:
            print(f"Backup failed for {device['hostname']}: {str(e)}")
    
    def backup_all_devices(self):
        for device in self.devices:
            self.backup_cisco_device(device)

# Device list
devices = [
    {'ip': '10.10.10.100', 'hostname': 'core-switch-1', 'username': 'admin', 'password': 'password'},
    {'ip': '10.10.10.101', 'hostname': 'firewall-1', 'username': 'admin', 'password': 'password'}
]

backup_manager = NetworkBackup(devices)

# Schedule daily backup at 2 AM
schedule.every().day.at("02:00").do(backup_manager.backup_all_devices)

# Run scheduler
while True:
    schedule.run_pending()
    time.sleep(3600)  # Check every hour

# network_latency_monitor.py
import subprocess
import time
import json
from datetime import datetime

class LatencyMonitor:
    def __init__(self, targets):
        self.targets = targets
        self.results = []
    
    def ping_host(self, host):
        try:
            result = subprocess.run(
                ['ping', '-c', '4', host], 
                capture_output=True, 
                text=True, 
                timeout=10
            )
            
            if result.returncode == 0:
                # Parse ping output for average latency
                lines = result.stdout.split('\n')
                for line in lines:
                    if 'avg' in line:
                        avg_latency = float(line.split('/')[4])
                        return avg_latency
            return None
            
        except Exception as e:
            print(f"Ping failed for {host}: {str(e)}")
            return None
    
    def monitor_all_targets(self):
        timestamp = datetime.now().isoformat()
        current_results = {'timestamp': timestamp, 'latencies': {}}
        
        for target in self.targets:
            latency = self.ping_host(target)
            current_results['latencies'][target] = latency
            
            if latency and latency > 100:  # Alert if latency > 100ms
                print(f"HIGH LATENCY ALERT: {target} - {latency}ms")
        
        self.results.append(current_results)
        
        # Save to file
        with open('/var/log/latency_monitor.json', 'w') as f:
            json.dump(self.results, f, indent=2)

# Monitor critical hosts
targets = ['8.8.8.8', '1.1.1.1', 'google.com', 'company-server.com']
monitor = LatencyMonitor(targets)

# Run every 5 minutes
while True:
    monitor.monitor_all_targets()
    time.sleep(300)

# Recommended enterprise approach
infrastructure_strategy = {
    'critical_systems': {
        'solution': 'commercial',
        'reason': 'vendor_support_required',
        'examples': ['core_firewall', 'load_balancer']
    },
    'monitoring_systems': {
        'solution': 'open_source',
        'reason': 'cost_effective_and_flexible',
        'examples': ['log_analysis', 'network_monitoring']
    },
    'edge_devices': {
        'solution': 'hybrid',
        'reason': 'balance_cost_and_reliability',
        'examples': ['branch_firewalls', 'access_points']
    }
}