방화벽 (Firewall)

네트워크 보안의 핵심 요소로, 내부 네트워크를 외부의 위협으로부터 보호하는 시스템.
방화벽은 미리 정의된 보안 규칙에 기반하여 들어오고 나가는 네트워크 트래픽을 모니터링하고 제어하는 네트워크 보안 시스템으로 신뢰할 수 있는 내부 네트워크와 신뢰할 수 없는 외부 네트워크(예: 인터넷) 사이의 장벽 역할을 한다.

방화벽의 기본 동작 원리

 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

class Firewall:
    def __init__(self):
        # 기본 규칙 설정
        self.rules = []
        self.default_policy = "DENY"  # 기본적으로 모든 트래픽 차단
        
    def add_rule(self, rule):
        """새로운 방화벽 규칙 추가"""
        self.rules.append(rule)
        
    def check_packet(self, packet):
        """패킷 검사 수행"""
        for rule in self.rules:
            if rule.matches(packet):
                return rule.action
        return self.default_policy

class FirewallRule:
    def __init__(self, protocol, src_ip, dst_ip, src_port, dst_port, action):
        self.protocol = protocol
        self.src_ip = src_ip
        self.dst_ip = dst_ip
        self.src_port = src_port
        self.dst_port = dst_port
        self.action = action  # "ALLOW" or "DENY"
        
    def matches(self, packet):
        """패킷이 규칙과 일치하는지 확인"""
        return (
            self.protocol == packet.protocol and
            self.src_ip.matches(packet.src_ip) and
            self.dst_ip.matches(packet.dst_ip) and
            self.src_port.matches(packet.src_port) and
            self.dst_port.matches(packet.dst_port)
        )

주요 기능

  1. 접근 통제(Access Control):

    • 패킷 필터링을 통해 외부에서 내부 네트워크로의 접근을 통제한다.
    • IP 주소와 서비스 포트를 검사하여 접근 허용 여부를 결정한다.

  2. 인증(Authentication):

    • 메시지, 사용자, 클라이언트에 대한 인증을 수행한다.

  3. 감사 및 로깅(Auditing & Logging):

    • 정책 설정, 관리자 접근, 네트워크 트래픽 등에 대한 로그를 기록한다.

  4. 프록시(Proxy) 기능:

    • 클라이언트의 요청을 대신 받아 서버에 전달하고 결과를 반환한다.

  5. NAT(Network Address Translation):

    • 내부 네트워크의 IP 주소를 외부에 노출시키지 않고 변환하여 통신한다.

동작 원리

방화벽은 기본적으로 모든 접근을 거부(deny)한 후, 허용할 접근만 단계적으로 허용(allow/permit)하는 방식으로 작동한다.
약 65,000개의 통신 포트 중 필요한 포트만을 선별적으로 개방하여 보안을 유지한다.

주요 유형

  1. 패킷 필터링 방화벽:
    가장 기본적인 형태의 방화벽으로, 패킷의 헤더 정보를 기반으로 필터링을 수행한다.

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

    class PacketFilterFirewall(Firewall):
    def inspect_packet(self, packet):
        """패킷 헤더 검사"""
        # IP 주소, 포트 번호, 프로토콜 등 확인
        header_info = {
            'src_ip': packet.get_source_ip(),
            'dst_ip': packet.get_destination_ip(),
            'src_port': packet.get_source_port(),
            'dst_port': packet.get_destination_port(),
            'protocol': packet.get_protocol()
        }

        # 규칙 확인
        for rule in self.rules:
            if self.match_rule(header_info, rule):
                return rule.action

        return self.default_policy

  2. 상태 검사 방화벽:
    연결 상태를 추적하여 더 정교한 필터링을 수행한다.

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

    class StatefulFirewall(Firewall):
    def __init__(self):
        super().__init__()
        self.connection_table = {}  # 연결 상태 추적

    def track_connection(self, packet):
        """연결 상태 추적"""
        connection_id = self.get_connection_id(packet)

        if packet.is_new_connection():
            # 새로운 연결 시작
            self.connection_table[connection_id] = {
                'state': 'NEW',
                'start_time': time.time(),
                'packets_in': 1,
                'packets_out': 0
            }
        else:
            # 기존 연결 업데이트
            if connection_id in self.connection_table:
                self.update_connection_state(connection_id, packet)

  3. 애플리케이션 계층 방화벽:
    애플리케이션 레벨의 데이터를 검사할 수 있다.

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

    class ApplicationFirewall(Firewall):
    def inspect_application_data(self, packet):
        """애플리케이션 데이터 검사"""
        if packet.protocol == "HTTP":
            return self.inspect_http_traffic(packet)
        elif packet.protocol == "DNS":
            return self.inspect_dns_traffic(packet)
        # 기타 프로토콜 처리

    def inspect_http_traffic(self, packet):
        """HTTP 트래픽 검사"""
        http_data = packet.get_http_data()

        # URL 필터링
        if not self.is_allowed_url(http_data.url):
            return "DENY"

        # 콘텐츠 검사
        if self.contains_malicious_content(http_data.body):
            return "DENY"

        return "ALLOW"

구현 시 고려해야 할 주요 보안 기능들

  1. 접근 제어 목록(ACL) 관리:

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

    class AccessControlList:
    def __init__(self):
        self.acl_rules = {}

    def add_rule(self, source, destination, permission):
        """ACL 규칙 추가"""
        rule_key = f"{source}->{destination}"
        self.acl_rules[rule_key] = permission

    def check_access(self, source, destination):
        """접근 권한 확인"""
        rule_key = f"{source}->{destination}"
        return self.acl_rules.get(rule_key, "DENY")

  2. 로깅과 모니터링:

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

    class FirewallLogger:
    def __init__(self):
        self.log_file = "firewall.log"

    def log_event(self, event_type, details):
        """보안 이벤트 로깅"""
        timestamp = datetime.now().isoformat()
        log_entry = {
            'timestamp': timestamp,
            'type': event_type,
            'details': details
        }

        with open(self.log_file, 'a') as f:
            json.dump(log_entry, f)
            f.write('\n')

  3. 침입 탐지:

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

    class IntrusionDetection:
    def __init__(self):
        self.signature_database = self.load_signatures()
        self.anomaly_detector = AnomalyDetector()

    def analyze_traffic(self, packet):
        """트래픽 분석 및 침입 탐지"""
        # 시그니처 기반 탐지
        if self.match_signatures(packet):
            return "THREAT_DETECTED"

        # 이상 행동 탐지
        if self.anomaly_detector.detect(packet):
            return "ANOMALY_DETECTED"

        return "NORMAL"

구축 시 고려해야 할 주요 사항들

  1. 성능 최적화:

    • 규칙 평가 순서 최적화
    • 캐싱 메커니즘 구현
    • 병렬 처리 활용

  2. 고가용성:

    • 이중화 구성
    • 장애 복구 메커니즘
    • 부하 분산

  3. 관리 용이성:

    • 직관적인 관리 인터페이스
    • 규칙 검증 메커니즘
    • 변경 이력 관리

  4. 보안 정책:

    • 최소 권한 원칙 적용
    • 기본 거부(Default Deny) 정책
    • 정기적인 규칙 검토 및 업데이트

참고 및 출처