라우팅 실습과 진단

Step 1: TTL=1인 패킷 전송
  PC ──[TTL=1]──→ R1 ──X (TTL 만료)
                   │
                   └──→ PC에게 ICMP Time Exceeded 응답
                        "나는 192.168.1.1 이야, 2ms 걸렸어"

Step 2: TTL=2인 패킷 전송
  PC ──[TTL=2]──→ R1 ──[TTL=1]──→ R2 ──X (TTL 만료)
                                    │
                                    └──→ PC에게 ICMP Time Exceeded
                                         "나는 10.0.0.1 이야, 5ms"

Step 3: TTL=3인 패킷 전송
  PC ──[TTL=3]──→ R1 ──[TTL=2]──→ R2 ──[TTL=1]──→ R3 ──X
                                                     │
                                                     └──→ "12ms"

Step N: TTL=N으로 목적지 도달
  PC ──[TTL=N]──→ ... ──→ 목적지 서버
                           │
                           └──→ ICMP Echo Reply (도착!)

정상적인 결과
 1  192.168.1.1      1 ms    1 ms    1 ms    ← 일관된 응답
 2  10.0.0.1         5 ms    5 ms    5 ms
 3  172.16.0.1      12 ms   12 ms   12 ms
 4  목적지           35 ms   35 ms   35 ms

패턴 1: 특정 홉에서 급격한 지연 증가
 3  172.16.0.1      12 ms   12 ms   12 ms
 4  203.0.113.1    150 ms  148 ms  152 ms   ← 3→4에서 138ms 증가
 5  목적지          151 ms  150 ms  149 ms   ← 이후로도 지연 유지
 → 홉 4 이전 구간(해저 케이블 등)에서 물리적 지연

패턴 2: 특정 홉에서만 지연 (이후 회복)
 3  172.16.0.1      12 ms   12 ms   12 ms
 4  203.0.113.1    200 ms  195 ms  210 ms   ← 높은 지연
 5  목적지           15 ms   14 ms   15 ms   ← 정상 복귀
 → 홉 4의 라우터가 ICMP 응답을 낮은 우선순위로 처리 (문제 아님)

패턴 3: 특정 홉부터 전부 * * *
 3  172.16.0.1      12 ms   12 ms   12 ms
 4  * * *
 5  * * *
 → 홉 4에서 패킷 차단 (방화벽) 또는 목적지 도달 불가

패턴 4: 루프 감지
 3  172.16.0.1      12 ms
 4  10.0.0.1         8 ms
 5  172.16.0.1      12 ms   ← 홉 3과 동일한 IP!
 6  10.0.0.1         8 ms
 → 라우팅 루프 발생 (긴급 대응 필요)

#!/bin/bash
# === ping 심화 진단 ===

echo "=== 기본 ping (4패킷) ==="
ping -c 4 google.com

echo ""
echo "=== MTU 확인 (Don't Fragment + 크기 지정) ==="
# Linux: -M do (Don't Fragment), -s (페이로드 크기)
# 1472 = 1500(MTU) - 20(IP헤더) - 8(ICMP헤더)
ping -c 1 -M do -s 1472 google.com
# 성공하면 MTU가 1500 이상
# "Frag needed" 오류 → 경로상 MTU가 1500 미만

echo ""
echo "=== 응답 시간 통계 ==="
ping -c 20 google.com | tail -3
# rtt min/avg/max/mdev = 2.123/3.456/15.789/2.345 ms
# mdev(표준편차)가 크면 → 네트워크 불안정 (jitter 높음)

echo ""
echo "=== 특정 인터페이스에서 ping ==="
ping -c 4 -I eth0 8.8.8.8

echo ""
echo "=== TTL 지정 ping ==="
# TTL을 5로 설정 → 5홉 이내에 도달하는지 확인
ping -c 4 -t 5 google.com

echo ""
echo "=== Windows에서 연속 ping ==="
# ping -t google.com      (Ctrl+C로 중지)
# ping -l 1472 -f google.com  (MTU 확인, -f = Don't Fragment)

A → B (갈 때)
  A ──→ ISP-A ──→ IX ──→ ISP-B ──→ B
                    (경로 1)

B → A (올 때)
  B ──→ ISP-B ──→ ISP-C ──→ ISP-A ──→ A
                    (경로 2, 다른 경로!)

BGP 정책에 의해 각 방향의 최적 경로가 다름
→ traceroute로 확인하는 경로 ≠ 응답이 돌아오는 경로

                        Packets               Pings
Host                  Loss%   Snt   Last   Avg  Best  Wrst StDev
1. 192.168.1.1         0.0%   100    0.8   0.9   0.5   2.1   0.3
2. 10.0.0.1            0.0%   100    5.2   5.5   4.1   8.3   0.8
3. 172.16.0.1          2.0%   100   12.1  12.8  10.2  45.3   5.2
4. 72.14.204.68        2.0%   100   35.4  36.1  33.2  52.1   3.1
5. 142.250.196.110     0.0%   100   36.2  36.8  34.1  41.2   1.5

분석
  홉 3: 2% 패킷 손실 + StDev 높음 → 이 구간에 간헐적 혼잡
  홉 4: 2% 손실은 홉 3에서 전파된 것 (누적)
  홉 5: 0% 손실 → 홉 3의 손실이 재전송으로 복구됨

import subprocess
import re
import sys
import statistics

def run_ping(host, count=10):
    """ping 테스트 수행 및 결과 분석"""
    cmd = ["ping", "-c", str(count), host]
    if sys.platform == "win32":
        cmd = ["ping", "-n", str(count), host]

    result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
    output = result.stdout

    # RTT 시간 파싱
    if sys.platform == "win32":
        times = re.findall(r'time[=<](\d+)ms', output)
    else:
        times = re.findall(r'time=(\d+\.?\d*)', output)

    times = [float(t) for t in times]

    if not times:
        return {"host": host, "status": "unreachable", "loss": 100}

    # 패킷 손실률 계산
    loss_match = re.search(r'(\d+)% packet loss', output)
    loss = int(loss_match.group(1)) if loss_match else 0

    return {
        "host": host,
        "status": "ok" if loss < 5 else "degraded" if loss < 20 else "critical",
        "loss": loss,
        "min_rtt": min(times),
        "avg_rtt": statistics.mean(times),
        "max_rtt": max(times),
        "jitter": statistics.stdev(times) if len(times) > 1 else 0,
        "samples": len(times),
    }

def diagnose_path(host):
    """경로 진단 수행"""
    print(f"=== {host} 경로 진단 ===\n")

    # 1. ping 테스트
    ping_result = run_ping(host)
    print(f"[Ping] 상태: {ping_result['status']}")
    if ping_result["status"] != "unreachable":
        print(f"  손실률: {ping_result['loss']}%")
        print(f"  RTT: min={ping_result['min_rtt']:.1f}ms "
              f"avg={ping_result['avg_rtt']:.1f}ms "
              f"max={ping_result['max_rtt']:.1f}ms")
        print(f"  Jitter: {ping_result['jitter']:.1f}ms")

    # 2. 진단 결과 해석
    print(f"\n[진단]")
    if ping_result["status"] == "unreachable":
        print("  ✗ 호스트 도달 불가")
        print("  → DNS 확인, 방화벽 확인, 라우팅 확인 필요")
    elif ping_result["loss"] > 0:
        print(f"  △ 패킷 손실 {ping_result['loss']}% 감지")
        print("  → MTR로 손실 구간 특정 권장")
    elif ping_result["jitter"] > 10:
        print(f"  △ 높은 Jitter ({ping_result['jitter']:.1f}ms)")
        print("  → 네트워크 혼잡 또는 무선 간섭 가능성")
    else:
        print("  ✓ 네트워크 상태 양호")

# 주요 목적지 진단
targets = ["8.8.8.8", "1.1.1.1"]
for target in targets:
    diagnose_path(target)
    print()