에러 핸들링과 안전한 스크립트

# ⚠️ 이 코드는 허가된 환경에서만 사용하세요.
import socket

# ❌ 너무 광범위 — 디버깅 어려움
def bad_check(host, port):
    try:
        socket.create_connection((host, port), timeout=2)
        return True
    except Exception:  # 모든 예외를 삼킴
        return False

# ✅ 예외별로 다른 의미
def good_check(host: str, port: int, timeout: float = 2.0) -> tuple[bool, str]:
    try:
        socket.create_connection((host, port), timeout=timeout)
        return True, 'open'
    except socket.timeout:
        return False, 'timeout'
    except ConnectionRefusedError:
        return False, 'refused'
    except socket.gaierror:
        return False, 'dns_error'
    except OSError as e:
        return False, f'os_error: {e}'

import logging

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s',
    handlers=[
        logging.FileHandler('security_scan.log', encoding='utf-8'),
        logging.StreamHandler(),  # 콘솔 + 파일 동시 출력
    ],
)

log = logging.getLogger('whitehat')

def scan(host: str, port: int):
    log.info(f'스캔 시작: {host}:{port}')
    ok, reason = good_check(host, port)
    if ok:
        log.warning(f'포트 열림: {host}:{port}')
    else:
        log.debug(f'포트 닫힘 ({reason}): {host}:{port}')
    return ok

import ipaddress

def validate_target(target: str) -> str:
    """스캔 대상 IP 검증 — 사설망 또는 자기 IP만 허용."""
    try:
        ip = ipaddress.ip_address(target)
    except ValueError:
        raise ValueError(f'유효하지 않은 IP: {target}')
    if ip.is_global:
        raise PermissionError(f'공용 IP는 허가된 환경에서만 — 거부: {target}')
    if not (ip.is_private or ip.is_loopback):
        raise PermissionError(f'사설망/루프백만 허용: {target}')
    return str(ip)

# 테스트
for t in ['127.0.0.1', '192.168.1.10', '8.8.8.8', '10.0.0.1', 'invalid']:
    try:
        ok = validate_target(t)
        print(f'✅ {t}')
    except (ValueError, PermissionError) as e:
        print(f'❌ {t}: {e}')

import socket
import logging
from concurrent.futures import ThreadPoolExecutor, as_completed

log = logging.getLogger('whitehat.portscan')

def check_port(host: str, port: int, timeout: float = 1.0) -> tuple[int, bool, str]:
    """단일 포트 체크 — 어떤 예외도 누설 안 함."""
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.settimeout(timeout)
    try:
        s.connect((host, port))
        return port, True, 'open'
    except socket.timeout:
        return port, False, 'timeout'
    except ConnectionRefusedError:
        return port, False, 'refused'
    except OSError as e:
        return port, False, f'error:{e.errno}'
    finally:
        s.close()

def scan_ports(host: str, ports: list[int], workers: int = 50) -> list[int]:
    """병렬 포트 스캔 — 예외에도 끝까지 완료."""
    open_ports = []
    with ThreadPoolExecutor(max_workers=workers) as ex:
        futures = {ex.submit(check_port, host, p): p for p in ports}
        for fut in as_completed(futures):
            try:
                port, ok, reason = fut.result()
                if ok:
                    open_ports.append(port)
                    log.info(f'{host}:{port} {reason}')
            except Exception as e:
                # 절대 도달 안 함 (check_port가 모든 예외 처리) — 안전망
                log.error(f'예상 못한 예외: {e}')
    return sorted(open_ports)