第8天：IP地址详解

# day08_ip_analyzer.py
# 功能：IP地址分析工具

import socket
import struct
import re

class IPAnalyzer:
    """IP地址分析器"""

    def __init__(self):
        # 私网IP地址范围
        self.private_ranges = [
            ('10.0.0.0', '10.255.255.255'),
            ('172.16.0.0', '172.31.255.255'),
            ('192.168.0.0', '192.168.255.255')
        ]

    def ip_to_int(self, ip):
        """
        将IP地址转换为整数

        参数：
            ip: IP地址字符串（如 "192.168.1.1"）

        返回：
            整数形式的IP

        工作原理：
            192.168.1.1 = 192*256^3 + 168*256^2 + 1*256 + 1
        """
        parts = ip.split('.')
        return (int(parts[0]) << 24) + (int(parts[1]) << 16) + \
               (int(parts[2]) << 8) + int(parts[3])

    def int_to_ip(self, num):
        """
        将整数转换为IP地址

        参数：
            num: 整数形式的IP

        返回：
            IP地址字符串
        """
        return f"{(num >> 24) & 255}.{(num >> 16) & 255}." \
               f"{(num >> 8) & 255}.{num & 255}"

    def ip_to_binary(self, ip):
        """
        将IP地址转换为二进制表示

        参数：
            ip: IP地址字符串

        返回：
            二进制字符串（用点分隔）
        """
        parts = ip.split('.')
        binary_parts = [format(int(part), '08b') for part in parts]
        return '.'.join(binary_parts)

    def validate_ip(self, ip):
        """
        验证IP地址格式是否正确

        参数：
            ip: IP地址字符串

        返回：
            True/False
        """
        pattern = r'^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$'
        match = re.match(pattern, ip)

        if not match:
            return False

        # 检查每个数字是否在0-255范围内
        for num in match.groups():
            if int(num) > 255:
                return False

        return True

    def get_ip_class(self, ip):
        """
        判断IP地址的类别（A/B/C/D/E类）

        参数：
            ip: IP地址字符串

        返回：
            类别字符串和详细信息
        """
        first_octet = int(ip.split('.')[0])

        if 1 <= first_octet <= 126:
            return 'A', '大型网络', '1-126'
        elif 128 <= first_octet <= 191:
            return 'B', '中型网络', '128-191'
        elif 192 <= first_octet <= 223:
            return 'C', '小型网络', '192-223'
        elif 224 <= first_octet <= 239:
            return 'D', '组播地址', '224-239'
        elif 240 <= first_octet <= 255:
            return 'E', '保留地址', '240-255'
        else:
            return '未知', '特殊地址', '0或127'

    def is_private_ip(self, ip):
        """
        判断是否为私网IP

        参数：
            ip: IP地址字符串

        返回：
            True/False
        """
        ip_int = self.ip_to_int(ip)

        for start, end in self.private_ranges:
            start_int = self.ip_to_int(start)
            end_int = self.ip_to_int(end)

            if start_int <= ip_int <= end_int:
                return True

        return False

    def is_special_ip(self, ip):
        """
        判断是否为特殊IP地址

        参数：
            ip: IP地址字符串

        返回：
            (是否特殊, 类型说明)
        """
        # 环回地址
        if ip.startswith('127.'):
            return True, '环回地址（Loopback）'

        # 默认路由
        if ip == '0.0.0.0':
            return True, '默认路由/任意地址'

        # 受限广播
        if ip == '255.255.255.255':
            return True, '受限广播地址'

        # 网络地址（主机号全0）
        if ip.endswith('.0'):
            return True, '网络地址'

        # 广播地址（主机号全255）
        if ip.endswith('.255'):
            return True, '广播地址'

        return False, ''

    def analyze(self, ip):
        """
        全面分析IP地址

        参数：
            ip: IP地址字符串

        返回：
            分析结果字典
        """
        if not self.validate_ip(ip):
            return {'valid': False, 'error': 'IP地址格式不正确'}

        result = {
            'valid': True,
            'ip': ip,
            'binary': self.ip_to_binary(ip),
            'integer': self.ip_to_int(ip),
            'class': self.get_ip_class(ip),
            'is_private': self.is_private_ip(ip),
            'is_public': not self.is_private_ip(ip) and not self.is_special_ip(ip)[0],
            'special': self.is_special_ip(ip)
        }

        return result

    def print_analysis(self, ip):
        """
        打印IP地址分析结果

        参数：
            ip: IP地址字符串
        """
        print("=" * 70)
        print("IP地址分析结果".center(70))
        print("=" * 70)

        result = self.analyze(ip)

        if not result['valid']:
            print(f"\n❌ {result['error']}")
            return

        print(f"\n📍 IP地址: {result['ip']}")
        print(f"🔢 十进制: {result['integer']}")
        print(f"💾 二进制: {result['binary']}")

        ip_class, usage, range_str = result['class']
        print(f"\n📊 地址类别: {ip_class}类")
        print(f"   用途: {usage}")
        print(f"   范围: {range_str}")

        print(f"\n🌐 地址类型:")
        if result['special'][0]:
            print(f"   ⭐ {result['special'][1]}")
        elif result['is_private']:
            print(f"   🏠 私网IP（不能在互联网上直接访问）")
        else:
            print(f"   🌍 公网IP（可以在互联网上直接访问）")

        print("\n" + "=" * 70)

def get_local_ips():
    """
    获取本机所有IP地址

    返回：
        IP地址列表
    """
    try:
        # 获取主机名
        hostname = socket.gethostname()

        # 获取所有IP
        ips = socket.gethostbyname_ex(hostname)[2]

        return ips
    except:
        return []

def main():
    """
    主函数
    """
    analyzer = IPAnalyzer()

    print("=" * 70)
    print("IP地址分析工具".center(70))
    print("=" * 70)

    # 显示本机IP
    local_ips = get_local_ips()
    if local_ips:
        print("\n💻 本机IP地址:")
        for ip in local_ips:
            print(f"   {ip}")

    print("\n" + "-" * 70)

    while True:
        print("\n请选择操作:")
        print("1. 分析IP地址")
        print("2. IP地址转换（十进制 ↔ 二进制）")
        print("3. 批量分析")
        print("0. 退出")

        choice = input("\n请输入选项: ").strip()

        if choice == '0':
            print("\n再见！")
            break

        elif choice == '1':
            ip = input("\n请输入IP地址: ").strip()
            if ip:
                analyzer.print_analysis(ip)

        elif choice == '2':
            ip = input("\n请输入IP地址: ").strip()
            if ip and analyzer.validate_ip(ip):
                print(f"\n十进制: {ip}")
                print(f"二进制: {analyzer.ip_to_binary(ip)}")
                print(f"整数: {analyzer.ip_to_int(ip)}")

        elif choice == '3':
            print("\n请输入多个IP地址（每行一个，输入空行结束）:")
            ips = []
            while True:
                ip = input().strip()
                if not ip:
                    break
                ips.append(ip)

            print(f"\n{'IP地址':<18} {'类别':<8} {'类型':<15}")
            print("-" * 45)

            for ip in ips:
                result = analyzer.analyze(ip)
                if result['valid']:
                    ip_class = result['class'][0]
                    if result['special'][0]:
                        ip_type = result['special'][1][:12]
                    elif result['is_private']:
                        ip_type = '私网'
                    else:
                        ip_type = '公网'

                    print(f"{ip:<18} {ip_class:<8} {ip_type:<15}")

if __name__ == "__main__":
    main()

python code/day08/day08_ip_analyzer.py