1
2
3
4
5
6
7
8
9

import ipaddress

# CIDR 네트워크 객체 생성
net = ipaddress.ip_network('192.168.1.0/24')
print("네트워크 주소:", net.network_address)  # 네트워크 주소 출력
print("서브넷 마스크:", net.netmask)         # 서브넷 마스크 출력
print("가능한 호스트 개수:", net.num_addresses)  # IP 범위 개수
print("첫번째 할당 IP:", list(net.hosts()))   # 첫 번째 호스트 IP
print("마지막 할당 IP:", list(net.hosts())[-1])  # 마지막 호스트 IP

1
2
3

# 서브넷을 /28로 분할
for sub_net in net.subnets(new_prefix=28):
    print("서브넷:", sub_net)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# Azure Python SDK로 VNet/CIDR 생성 예시
from azure.mgmt.network import NetworkManagementClient
network_client = NetworkManagementClient(credentials, subscription_id)
vnet_params = {
    'location': 'koreacentral',
    'address_space': {'address_prefixes': ['10.0.0.0/16']},
    'subnets': [
        {'name': 'WebSubnet', 'address_prefix': '10.0.1.0/24'},
        {'name': 'AppSubnet', 'address_prefix': '10.0.2.0/24'},
        {'name': 'DBSubnet', 'address_prefix': '10.0.3.0/24'}
    ]
}
network_client.virtual_networks.begin_create_or_update('myGroup', 'myVNet', vnet_params)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

라우팅 테이블:
- 192.168.0.0/16    → Interface A
- 192.168.1.0/24    → Interface B  
- 192.168.1.64/26   → Interface C
- 0.0.0.0/0         → Default Gateway

목적지 192.168.1.100인 패킷:
1. 192.168.1.100은 192.168.0.0/16에 매칭 (16비트)
2. 192.168.1.100은 192.168.1.0/24에 매칭 (24비트)
3. 192.168.1.100은 192.168.1.64/26에 매칭하지 않음
4. 최장 매칭: 192.168.1.0/24 → Interface B 선택

1
2
3
4
5
6
7
8
9

IANA: 전체 IPv4 주소 공간 (0.0.0.0/0)
  ↓
APNIC: 아시아태평양 지역 블록 (예: 203.0.0.0/8)
  ↓  
Korean ISP: 국내 ISP 할당 블록 (예: 203.248.0.0/13)
  ↓
대기업 고객: 기업별 할당 블록 (예: 203.248.0.0/16)
  ↓
부서별 서브넷: 세부 네트워크 분할 (예: 203.248.1.0/24)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

BGP UPDATE 메시지 구조:
+-------------------+
| Withdrawn Routes  | ← CIDR 형식의 취소된 라우트
+-------------------+
| Path Attributes   | ← AS_PATH, NEXT_HOP 등
+-------------------+  
| Network Layer     | ← CIDR 형식의 광고할 라우트
| Reachability Info |
+-------------------+

예시:
Withdrawn Routes: 192.168.1.0/24, 10.0.0.0/16
NLRI: 203.248.0.0/16, 172.16.0.0/12

1
2
3
4
5

권장 접근법:
1. 신규 네트워크: CIDR 기반 설계 우선
2. 기존 네트워크: 점진적 CIDR 도입
3. 하이브리드: 핵심 구간만 CIDR 적용
4. 레거시 보존: 필수 구간만 클래스 기반 유지

1
2
3
4
5

1단계: 전체 주소 공간 확보 (예: 10.0.0.0/8)
2단계: 지역별 분할 (예: 서울 10.1.0.0/16, 부산 10.2.0.0/16)
3단계: 건물별 분할 (예: A동 10.1.1.0/24, B동 10.1.2.0/24)
4단계: 층별 분할 (예: 1층 10.1.1.0/26, 2층 10.1.1.64/26)
5단계: 용도별 분할 (예: 사무용 10.1.1.0/28, 서버용 10.1.1.16/28)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

1단계: 각 부서별 호스트 수 조사
   - 개발팀: 50대 → /26 필요 (62개 주소)
   - 마케팅팀: 20대 → /27 필요 (30개 주소)
   - 관리팀: 10대 → /28 필요 (14개 주소)

2단계: 여유분 포함 계산 (30% 성장 고려)
   - 개발팀: 65대 → /26 유지
   - 마케팅팀: 26대 → /27 유지  
   - 관리팀: 13대 → /28 유지

3단계: 연속된 주소 공간 할당
   - 192.168.1.0/26 → 개발팀
   - 192.168.1.64/27 → 마케팅팀
   - 192.168.1.96/28 → 관리팀
   - 192.168.1.112/28 → 예비

4단계: 상위 집약 확인
   - 전체: 192.168.1.0/24로 집약 가능

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

# VLSM 계산 예제
def calculate_vlsm(network, requirements):
    """
    VLSM 서브넷 계산 함수
    network: 기본 네트워크 (예: "192.168.1.0/24")
    requirements: 각 서브넷별 호스트 수 요구사항
    """
    import ipaddress
    
    # 기본 네트워크 정의
    base_network = ipaddress.IPv4Network(network)
    print(f"기본 네트워크: {base_network}")
    print(f"사용 가능한 주소 수: {base_network.num_addresses - 2}")
    
    # 요구사항을 호스트 수 기준으로 정렬 (큰 것부터)
    sorted_reqs = sorted(requirements.items(), key=lambda x: x[1], reverse=True)
    
    allocated_subnets = []
    current_network = base_network.network_address
    
    for dept, host_count in sorted_reqs:
        # 필요한 접두사 길이 계산 (2^n >= host_count + 2)
        import math
        needed_bits = math.ceil(math.log2(host_count + 2))
        prefix_length = 32 - needed_bits
        
        # 서브넷 생성
        subnet = ipaddress.IPv4Network(f"{current_network}/{prefix_length}")
        allocated_subnets.append((dept, subnet, host_count))
        
        print(f"{dept}: {subnet} ({subnet.num_addresses - 2}개 호스트)")
        
        # 다음 서브넷을 위한 주소 계산
        current_network = subnet.broadcast_address + 1
    
    return allocated_subnets

# 사용 예시
requirements = {
    "개발팀": 50,
    "마케팅팀": 20, 
    "관리팀": 10,
    "서버실": 8,
    "게스트": 5
}

subnets = calculate_vlsm("192.168.1.0/24", requirements)

1
2
3
4

BGP-4 (RFC 4271) 준수사항:
- CIDR 형식의 NLRI (Network Layer Reachability Information) 지원
- 경로 집약 (Route Aggregation) 기능
- 접두사 길이 기반 최장 매칭

1
2
3
4

OSPFv2 (RFC 2328) 준수사항:
- Variable Length Subnet Masks (VLSM) 지원
- 라우팅 테이블의 CIDR 엔트리 처리
- 외부 라우트의 CIDR 형식 광고

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

import ipaddress
import math
from typing import Dict, List, Tuple

# 기업 네트워크 요구사항 정의
class NetworkRequirement:
    def __init__(self, name: str, host_count: int, growth_factor: float = 1.3):
        self.name = name
        self.host_count = host_count
        self.growth_factor = growth_factor
        # 30% 성장여유를 고려한 실제 필요 호스트 수
        self.actual_need = int(host_count * growth_factor)
    
    def calculate_prefix_length(self) -> int:
        """호스트 수를 기반으로 필요한 접두사 길이 계산"""
        # 네트워크 주소와 브로드캐스트 주소 제외
        needed_addresses = self.actual_need + 2
        # 2의 거듭제곱으로 올림
        needed_bits = math.ceil(math.log2(needed_addresses))
        return 32 - needed_bits

# 가상의 ABC 기업 네트워크 요구사항
company_requirements = [
    NetworkRequirement("본사_개발팀", 120),
    NetworkRequirement("본사_영업팀", 80),
    NetworkRequirement("본사_관리팀", 40),
    NetworkRequirement("본사_서버실", 30),
    NetworkRequirement("지사1_사무실", 60),
    NetworkRequirement("지사2_사무실", 45),
    NetworkRequirement("DMZ_웹서버", 10),
    NetworkRequirement("DMZ_메일서버", 5),
    NetworkRequirement("게스트_네트워크", 50),
    NetworkRequirement("관리_네트워크", 20)
]

print("=== ABC 기업 네트워크 요구사항 분석 ===")
total_hosts = 0
for req in company_requirements:
    prefix = req.calculate_prefix_length()
    available_hosts = (2 ** (32 - prefix)) - 2
    total_hosts += req.actual_need
    print(f"{req.name}: {req.host_count}대 → {req.actual_need}대 (여유분 포함)")
    print(f"  필요 접두사: /{prefix} (사용가능: {available_hosts}개)")

print(f"\n총 필요 호스트 수: {total_hosts}개")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

def design_vlsm_network(base_network: str, requirements: List[NetworkRequirement]) -> List[Tuple[str, ipaddress.IPv4Network, int]]:
    """
    VLSM을 사용하여 네트워크를 효율적으로 분할
    base_network: 기본 네트워크 (예: "10.0.0.0/16")
    requirements: 네트워크 요구사항 리스트
    """
    base_net = ipaddress.IPv4Network(base_network)
    print(f"\n=== VLSM 네트워크 설계 (기본: {base_net}) ===")
    
    # 호스트 수가 많은 순서로 정렬 (큰 서브넷부터 할당)
    sorted_reqs = sorted(requirements, key=lambda x: x.actual_need, reverse=True)
    
    allocated_subnets = []
    current_address = base_net.network_address
    
    for req in sorted_reqs:
        prefix_length = req.calculate_prefix_length()
        
        try:
            # 현재 주소에서 시작하는 서브넷 생성
            subnet = ipaddress.IPv4Network(f"{current_address}/{prefix_length}")
            
            # 기본 네트워크 범위 내에 있는지 확인
            if not subnet.subnet_of(base_net):
                print(f"오류: {req.name}을 위한 충분한 주소 공간이 없습니다.")
                break
                
            allocated_subnets.append((req.name, subnet, req.actual_need))
            
            print(f"{req.name}:")
            print(f"  할당 네트워크: {subnet}")
            print(f"  사용가능 호스트: {subnet.num_addresses - 2}개")
            print(f"  실제 필요량: {req.actual_need}개")
            print(f"  효율성: {(req.actual_need / (subnet.num_addresses - 2)) * 100:.1f}%")
            
            # 다음 서브넷을 위한 주소 계산
            current_address = subnet.broadcast_address + 1
            
        except ValueError as e:
            print(f"오류: {req.name} 할당 실패 - {e}")
            break
    
    return allocated_subnets

# VLSM 설계 실행
allocated_networks = design_vlsm_network("10.0.0.0/16", company_requirements)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

def analyze_routing_aggregation(subnets: List[Tuple[str, ipaddress.IPv4Network, int]]):
    """
    할당된 서브넷의 라우팅 집약 가능성 분석
    """
    print(f"\n=== 라우팅 집약 분석 ===")
    
    # 네트워크별 그룹화 (예: 본사, 지사, DMZ 등)
    groups = {
        "본사": [],
        "지사": [],
        "DMZ": [],
        "기타": []
    }
    
    for name, subnet, hosts in subnets:
        if "본사" in name:
            groups["본사"].append(subnet)
        elif "지사" in name:
            groups["지사"].append(subnet)
        elif "DMZ" in name:
            groups["DMZ"].append(subnet)
        else:
            groups["기타"].append(subnet)
    
    for group_name, networks in groups.items():
        if not networks:
            continue
            
        print(f"\n{group_name} 네트워크:")
        for net in networks:
            print(f"  {net}")
        
        # 집약 가능성 확인
        if len(networks) > 1:
            try:
                # 가장 작은 공통 상위 네트워크 찾기
                supernet = ipaddress.collapse_addresses(networks)
                supernet_list = list(supernet)
                
                if len(supernet_list) == 1:
                    print(f"  → 집약 가능: {supernet_list[0]}")
                else:
                    print(f"  → 집약 결과: {len(supernet_list)}개 블록")
                    for snet in supernet_list:
                        print(f"    {snet}")
            except:
                print(f"  → 집약 불가능 (비연속적 주소)")

analyze_routing_aggregation(allocated_networks)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

=== ABC 기업 네트워크 요구사항 분석 ===
본사_개발팀: 120대 → 156대 (여유분 포함)
  필요 접두사: /24 (사용가능: 254개)
본사_영업팀: 80대 → 104대 (여유분 포함)
  필요 접두사: /25 (사용가능: 126개)
...

=== VLSM 네트워크 설계 (기본: 10.0.0.0/16) ===
본사_개발팀:
  할당 네트워크: 10.0.0.0/24
  사용가능 호스트: 254개
  실제 필요량: 156개
  효율성: 61.4%
...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

class CloudVPCDesigner:
    def __init__(self, vpc_cidr: str, region_name: str):
        self.vpc_cidr = ipaddress.IPv4Network(vpc_cidr)
        self.region_name = region_name
        self.subnets = {}
        self.availability_zones = ["az-a", "az-b", "az-c"]
    
    def design_multi_az_subnets(self):
        """
        멀티 AZ 환경을 위한 서브넷 설계
        각 AZ별로 프라이빗/퍼블릭 서브넷 쌍 생성
        """
        print(f"=== {self.region_name} VPC 설계 ({self.vpc_cidr}) ===")
        
        # AZ당 /24씩 할당 (프라이빗 /25, 퍼블릭 /26, 예비 /26)
        az_networks = list(self.vpc_cidr.subnets(new_prefix=24))
        
        for i, az in enumerate(self.availability_zones):
            if i >= len(az_networks):
                break
                
            az_network = az_networks[i]
            
            # 각 AZ 내 서브넷 분할
            subnets = list(az_network.subnets(new_prefix=25))
            private_subnet = subnets[0]  # /25 (126 호스트)
            
            # 퍼블릭은 /26으로 더 작게 (62 호스트)
            public_subnets = list(subnets[1].subnets(new_prefix=26))
            public_subnet = public_subnets[0]
            reserved_subnet = public_subnets[1]  # 예비용
            
            self.subnets[az] = {
                'private': private_subnet,
                'public': public_subnet, 
                'reserved': reserved_subnet
            }
            
            print(f"\n{az} 가용영역:")
            print(f"  프라이빗 서브넷: {private_subnet} (DB, 앱서버)")
            print(f"  퍼블릭 서브넷:  {public_subnet} (로드밸런서, NAT)")
            print(f"  예비 서브넷:    {reserved_subnet} (향후 확장)")
    
    def generate_routing_table(self):
        """라우팅 테이블 생성"""
        print(f"\n=== 라우팅 테이블 ===")
        
        # 퍼블릭 라우팅 테이블
        print("퍼블릭 서브넷 라우팅:")
        print("  0.0.0.0/0 → Internet Gateway")
        for az, subnets in self.subnets.items():
            print(f"  {subnets['public']} → Local")
        
        # 프라이빗 라우팅 테이블  
        print("\n프라이빗 서브넷 라우팅:")
        print("  0.0.0.0/0 → NAT Gateway")
        for az, subnets in self.subnets.items():
            print(f"  {subnets['private']} → Local")

# 클라우드 VPC 설계 실행
vpc_designer = CloudVPCDesigner("10.0.0.0/16", "Seoul")
vpc_designer.design_multi_az_subnets()
vpc_designer.generate_routing_table()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# KT 네트워크 주소 체계 시뮬레이션
class ISPNetworkDesign:
    def __init__(self):
        # 할당받은 주소 블록 (예시)
        self.allocated_blocks = [
            "203.248.0.0/13",  # Seoul Region
            "203.249.0.0/13",  # Busan Region  
            "203.250.0.0/13"   # Daegu Region
        ]
    
    def design_hierarchical_allocation(self, region_block: str):
        """계층적 주소 할당 설계"""
        region_net = ipaddress.IPv4Network(region_block)
        print(f"지역 블록: {region_net}")
        print(f"총 사용가능 주소: {region_net.num_addresses:,}개")
        
        # Tier 2: 시/도 단위 분할 (/16)
        metro_networks = list(region_net.subnets(new_prefix=16))
        print(f"\n시/도별 할당 (/{16}):")
        
        metro_assignments = [
            "Seoul_Central", "Seoul_Gangnam", "Seoul_Gangbuk", 
            "Incheon", "Gyeonggi_North", "Gyeonggi_South"
        ]
        
        for i, metro in enumerate(metro_assignments[:len(metro_networks)]):
            metro_net = metro_networks[i]
            print(f"  {metro}: {metro_net} ({metro_net.num_addresses:,}개)")
            
            # Tier 3: 가입자 서비스 단위 (/20 ~ /22)
            service_nets = list(metro_net.subnets(new_prefix=20))
            print(f"    서비스 블록 수: {len(service_nets)}개 (각각 {service_nets[0].num_addresses}개)")

# 실행
isp_design = ISPNetworkDesign()
isp_design.design_hierarchical_allocation("203.248.0.0/13")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

# 글로벌 멀티클라우드 CIDR 설계
class GlobalCIDRDesign:
    def __init__(self):
        self.global_block = ipaddress.IPv4Network("10.0.0.0/8")
        self.regions = {
            "americas": {"base": "10.1.0.0/12", "countries": 16},
            "emea": {"base": "10.16.0.0/12", "countries": 16},  
            "apac": {"base": "10.32.0.0/12", "countries": 16}
        }
    
    def allocate_country_blocks(self, region_name: str):
        """국가별 /16 블록 할당"""
        region_info = self.regions[region_name]
        region_net = ipaddress.IPv4Network(region_info["base"])
        
        print(f"=== {region_name.upper()} 지역 할당 ===")
        print(f"지역 블록: {region_net}")
        
        # 국가별 /16 블록 생성
        country_blocks = list(region_net.subnets(new_prefix=16))
        
        # 샘플 국가 할당
        sample_countries = {
            "americas": ["US_East", "US_West", "Canada", "Brazil", "Mexico"],
            "emea": ["UK", "Germany", "France", "UAE", "South_Africa"],
            "apac": ["Korea", "Japan", "Singapore", "Australia", "India"]
        }
        
        countries = sample_countries.get(region_name, [])
        
        for i, country in enumerate(countries):
            if i < len(country_blocks):
                country_net = country_blocks[i]
                print(f"  {country}: {country_net}")
                
                # 각 국가 내 환경별 분할 (Dev/Staging/Prod)
                env_subnets = list(country_net.subnets(new_prefix=18))
                print(f"    Production:  {env_subnets[0]} (/18)")
                print(f"    Staging:     {env_subnets[1]} (/18)")  
                print(f"    Development: {env_subnets[2]} (/18)")
                print(f"    Reserved:    {env_subnets[3]} (/18)")

# 실행
global_design = GlobalCIDRDesign()
for region in ["americas", "emea", "apac"]:
    global_design.allocate_country_blocks(region)
    print()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

# 하이브리드 클라우드 CIDR 통합 예시
class HybridCloudCIDR:
    def __init__(self):
        self.networks = {
            "on_premise": "172.16.0.0/12",      # 기업 내부
            "aws_prod": "10.1.0.0/16",          # AWS 프로덕션
            "azure_dr": "10.2.0.0/16",          # Azure 재해복구
            "gcp_dev": "10.3.0.0/16"            # GCP 개발환경
        }
    
    def validate_no_overlap(self):
        """네트워크 간 중복 확인"""
        networks = [ipaddress.IPv4Network(cidr) for cidr in self.networks.values()]
        
        print("=== 네트워크 중복 검사 ===")
        for i, net1 in enumerate(networks):
            for j, net2 in enumerate(networks[i+1:], i+1):
                if net1.overlaps(net2):
                    print(f"❌ 중복 발견: {net1} ↔ {net2}")
                else:
                    print(f"✅ 정상: {net1} ↔ {net2}")
    
    def design_interconnect_routing(self):
        """상호 연결 라우팅 설계"""
        print("\n=== 상호 연결 라우팅 테이블 ===")
        
        for env, cidr in self.networks.items():
            print(f"\n{env} ({cidr}) 라우팅:")
            for other_env, other_cidr in self.networks.items():
                if env != other_env:
                    if "on_premise" in env:
                        gateway = "Enterprise_Router"
                    elif "aws" in env:
                        gateway = "AWS_Transit_Gateway"
                    elif "azure" in env:
                        gateway = "Azure_VPN_Gateway"
                    else:
                        gateway = "GCP_Cloud_Router"
                    
                    print(f"  {other_cidr} → {gateway}")

# 실행
hybrid_design = HybridCloudCIDR()
hybrid_design.validate_no_overlap()
hybrid_design.design_interconnect_routing()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

# CIDR 사용률 모니터링 시스템 예시
import ipaddress
import json
from datetime import datetime, timedelta

class CIDRMonitoring:
    def __init__(self):
        self.subnet_usage = {}
        self.thresholds = {
            "warning": 0.70,
            "critical": 0.85,
            "emergency": 0.95
        }
    
    def check_subnet_utilization(self, subnet_cidr: str, used_ips: int):
        """서브넷 사용률 검사 및 알림"""
        subnet = ipaddress.IPv4Network(subnet_cidr)
        total_usable = subnet.num_addresses - 2  # 네트워크/브로드캐스트 제외
        utilization = used_ips / total_usable
        
        # 사용률 기록
        self.subnet_usage[subnet_cidr] = {
            "timestamp": datetime.now().isoformat(),
            "used_ips": used_ips,
            "total_usable": total_usable,
            "utilization": utilization
        }
        
        # 임계값 검사 및 알림
        if utilization >= self.thresholds["emergency"]:
            return self._generate_alert("EMERGENCY", subnet_cidr, utilization)
        elif utilization >= self.thresholds["critical"]:
            return self._generate_alert("CRITICAL", subnet_cidr, utilization)
        elif utilization >= self.thresholds["warning"]:
            return self._generate_alert("WARNING", subnet_cidr, utilization)
        
        return {"status": "OK", "utilization": utilization}
    
    def _generate_alert(self, level: str, subnet: str, utilization: float):
        """알림 메시지 생성"""
        messages = {
            "WARNING": f"서브넷 {subnet} 사용률 {utilization:.1%} - 확장 계획 수립 필요",
            "CRITICAL": f"서브넷 {subnet} 사용률 {utilization:.1%} - 즉시 확장 또는 최적화 필요",
            "EMERGENCY": f"서브넷 {subnet} 사용률 {utilization:.1%} - 긴급 대응 필요!"
        }
        
        return {
            "status": level,
            "message": messages[level],
            "utilization": utilization,
            "timestamp": datetime.now().isoformat()
        }
    
    def predict_exhaustion(self, subnet_cidr: str, growth_rate_per_day: int):
        """IP 주소 고갈 시점 예측"""
        if subnet_cidr not in self.subnet_usage:
            return "데이터 부족"
        
        usage_data = self.subnet_usage[subnet_cidr]
        remaining_ips = usage_data["total_usable"] - usage_data["used_ips"]
        
        if growth_rate_per_day <= 0:
            return "현재 증가율로는 고갈 없음"
        
        days_to_exhaustion = remaining_ips / growth_rate_per_day
        exhaustion_date = datetime.now() + timedelta(days=days_to_exhaustion)
        
        return {
            "days_remaining": round(days_to_exhaustion, 1),
            "exhaustion_date": exhaustion_date.strftime("%Y-%m-%d"),
            "recommendation": self._get_expansion_recommendation(days_to_exhaustion)
        }
    
    def _get_expansion_recommendation(self, days_remaining: float):
        """확장 권장사항 제공"""
        if days_remaining < 30:
            return "즉시 확장 또는 대체 서브넷 할당 필요"
        elif days_remaining < 90:
            return "다음 분기 내 확장 계획 수립 권장"
        else:
            return "현재 수준 유지, 정기 모니터링 지속"

# 사용 예시
monitor = CIDRMonitoring()

# 실제 사용률 검사
result1 = monitor.check_subnet_utilization("192.168.1.0/24", 180)  # 70.9% 사용
result2 = monitor.check_subnet_utilization("10.0.1.0/28", 12)      # 85.7% 사용

print("사용률 검사 결과:")
print(f"192.168.1.0/24: {result1}")
print(f"10.0.1.0/28: {result2}")

# 고갈 예측
prediction = monitor.predict_exhaustion("10.0.1.0/28", 0.5)  # 일일 0.5개 증가
print(f"\n고갈 예측: {prediction}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

# 라우터 라우팅 테이블 모니터링 (의사코드)
class RouterMonitoring:
    def __init__(self):
        self.routers = {}
    
    def collect_routing_metrics(self, router_ip: str):
        """
        SNMP를 통한 라우팅 테이블 메트릭 수집
        실제 구현 시 pysnmp 라이브러리 사용
        """
        # SNMP OID for routing table entries
        # .1.3.6.1.2.1.4.21.1.1 (ipRouteTable)
        
        metrics = {
            "total_routes": 0,
            "cidr_routes": 0,
            "default_routes": 0,
            "memory_usage_mb": 0,
            "convergence_time_ms": 0
        }
        
        # 실제 SNMP 쿼리 로직 (예시)
        # for route in snmp_walk(router_ip, route_table_oid):
        #     if is_cidr_route(route):
        #         metrics["cidr_routes"] += 1
        #     metrics["total_routes"] += 1
        
        return metrics
    
    def analyze_aggregation_efficiency(self, routes: list):
        """라우트 집약 효율성 분석"""
        # 집약 가능한 라우트 쌍 찾기
        aggregatable_pairs = []
        
        for i, route1 in enumerate(routes):
            for j, route2 in enumerate(routes[i+1:], i+1):
                # 연속된 네트워크인지 확인
                if self._can_aggregate(route1, route2):
                    aggregatable_pairs.append((route1, route2))
        
        efficiency = 1 - (len(aggregatable_pairs) * 2 / len(routes))
        return {
            "efficiency_score": efficiency,
            "aggregatable_pairs": len(aggregatable_pairs),
            "potential_reduction": len(aggregatable_pairs)
        }

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

# CIDR 기반 보안 정책 생성기
class SecurityPolicyGenerator:
    def __init__(self):
        self.security_zones = {
            "dmz": {"cidr": "10.1.0.0/24", "security_level": "medium"},
            "internal": {"cidr": "10.2.0.0/16", "security_level": "high"},
            "guest": {"cidr": "10.3.0.0/24", "security_level": "low"},
            "management": {"cidr": "10.4.0.0/28", "security_level": "critical"}
        }
        
        self.default_policies = {
            "critical": ["deny_all_inbound", "log_all_traffic", "encrypt_required"],
            "high": ["deny_external_inbound", "allow_internal", "log_security_events"],
            "medium": ["allow_web_traffic", "deny_admin_ports", "basic_logging"],
            "low": ["allow_internet", "deny_internal", "minimal_logging"]
        }
    
    def generate_firewall_rules(self, source_zone: str, dest_zone: str):
        """존 간 방화벽 규칙 자동 생성"""
        source_info = self.security_zones.get(source_zone)
        dest_info = self.security_zones.get(dest_zone)
        
        if not source_info or not dest_info:
            return {"error": "존 정보 없음"}
        
        source_cidr = source_info["cidr"]
        dest_cidr = dest_info["cidr"] 
        source_level = source_info["security_level"]
        dest_level = dest_info["security_level"]
        
        rules = []
        
        # 보안 레벨 기반 규칙 생성
        if self._is_higher_security(source_level, dest_level):
            # 높은 보안 → 낮은 보안: 허용 (아웃바운드)
            rules.extend([
                f"ALLOW {source_cidr} → {dest_cidr} tcp/80,443",
                f"ALLOW {source_cidr} → {dest_cidr} udp/53",
                f"LOG {source_cidr} → {dest_cidr} any"
            ])
        elif self._is_lower_security(source_level, dest_level):
            # 낮은 보안 → 높은 보안: 제한적 허용
            rules.extend([
                f"DENY {source_cidr} → {dest_cidr} tcp/22,3389",
                f"ALLOW {source_cidr} → {dest_cidr} tcp/80,443",
                f"LOG {source_cidr} → {dest_cidr} any"
            ])
        else:
            # 동일 레벨: 기본 허용
            rules.extend([
                f"ALLOW {source_cidr} → {dest_cidr} any",
                f"LOG {source_cidr} → {dest_cidr} security_events"
            ])
        
        return {
            "source_zone": source_zone,
            "destination_zone": dest_zone,
            "rules": rules,
            "policy_basis": f"{source_level} → {dest_level}"
        }
    
    def _is_higher_security(self, source: str, dest: str):
        """보안 레벨 비교 (높음→낮음)"""
        levels = {"critical": 4, "high": 3, "medium": 2, "low": 1}
        return levels.get(source, 0) > levels.get(dest, 0)
    
    def _is_lower_security(self, source: str, dest: str):
        """보안 레벨 비교 (낮음→높음)"""
        levels = {"critical": 4, "high": 3, "medium": 2, "low": 1}
        return levels.get(source, 0) < levels.get(dest, 0)
    
    def generate_compliance_report(self):
        """규정 준수 보고서 생성"""
        report = {
            "timestamp": datetime.now().isoformat(),
            "compliance_checks": [],
            "violations": [],
            "recommendations": []
        }
        
        # 네트워크 분리 검사
        for zone_name, zone_info in self.security_zones.items():
            cidr = ipaddress.IPv4Network(zone_info["cidr"])
            
            # PCI DSS 요구사항 검사 (예시)
            if zone_info["security_level"] == "critical":
                check = {
                    "standard": "PCI DSS 1.2",
                    "requirement": "네트워크 분리",
                    "zone": zone_name,
                    "cidr": str(cidr),
                    "status": "COMPLIANT",
                    "details": "중요 시스템이 별도 서브넷에 격리됨"
                }
            else:
                check = {
                    "standard": "ISO 27001",
                    "requirement": "네트워크 접근 제어",
                    "zone": zone_name,
                    "cidr": str(cidr),
                    "status": "COMPLIANT",
                    "details": "적절한 접근 제어 정책 적용"
                }
            
            report["compliance_checks"].append(check)
        
        return report

# 사용 예시
security_gen = SecurityPolicyGenerator()

# 존 간 방화벽 규칙 생성
dmz_to_internal = security_gen.generate_firewall_rules("dmz", "internal")
guest_to_management = security_gen.generate_firewall_rules("guest", "management")

print("=== 방화벽 규칙 자동 생성 ===")
print(f"DMZ → Internal: {dmz_to_internal}")
print(f"Guest → Management: {guest_to_management}")

# 컴플라이언스 보고서
compliance_report = security_gen.generate_compliance_report()
print(f"\n=== 규정 준수 현황 ===")
for check in compliance_report["compliance_checks"]:
    print(f"{check['standard']}: {check['status']} - {check['details']}")