import socket
import sys

def scan_port(target_host, target_port):
    """
    단일 포트를 스캔하는 함수
    
    Args:
        target_host: 스캔할 호스트 IP 또는 도메인
        target_port: 스캔할 포트 번호
    
    Returns:
        포트가 열려있으면 True, 닫혀있으면 False
    """
    try:
        # 소켓 생성 (IPv4, TCP)
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        
        # 타임아웃 설정 (1초)
        sock.settimeout(1)
        
        # 연결 시도
        result = sock.connect_ex((target_host, target_port))
        
        # 소켓 닫기
        sock.close()
        
        # result가 0이면 포트가 열려있음
        if result == 0:
            return True
        else:
            return False
            
    except socket.gaierror:
        print(f"호스트 이름을 확인할 수 없습니다: {target_host}")
        return False
    except socket.error:
        print(f"서버에 연결할 수 없습니다: {target_host}")
        return False

# 사용 예시
if __name__ == "__main__":
    host = "127.0.0.1"  # 로컬호스트
    port = 80
    
    print(f"[*] {host}의 포트 {port} 스캔 중...")
    
    if scan_port(host, port):
        print(f"[+] 포트 {port}이(가) 열려있습니다! ✅")
    else:
        print(f"[-] 포트 {port}이(가) 닫혀있습니다. ❌")

import socket
import sys
from datetime import datetime

def scan_port_range(target_host, start_port, end_port):
    """
    포트 범위를 스캔하는 함수
    
    Args:
        target_host: 스캔할 호스트
        start_port: 시작 포트 번호
        end_port: 종료 포트 번호
    """
    print("-" * 60)
    print(f"스캔 대상: {target_host}")
    print(f"포트 범위: {start_port} - {end_port}")
    print(f"스캔 시작 시간: {datetime.now()}")
    print("-" * 60)
    
    open_ports = []
    
    try:
        # 호스트 이름을 IP로 변환
        target_ip = socket.gethostbyname(target_host)
        print(f"[*] IP 주소: {target_ip}\n")
        
    except socket.gaierror:
        print(f"[!] 호스트 이름을 확인할 수 없습니다: {target_host}")
        sys.exit()
    
    # 포트 범위 스캔
    for port in range(start_port, end_port + 1):
        try:
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.settimeout(0.5)  # 빠른 스캔을 위해 타임아웃 단축
            
            result = sock.connect_ex((target_ip, port))
            
            if result == 0:
                # 서비스 이름 가져오기 시도
                try:
                    service = socket.getservbyport(port)
                except:
                    service = "Unknown"
                
                print(f"[+] 포트 {port:5d} : OPEN  ({service})")
                open_ports.append(port)
            
            sock.close()
            
        except KeyboardInterrupt:
            print("\n[!] 사용자에 의해 스캔이 중단되었습니다.")
            sys.exit()
        except socket.error:
            pass
    
    # 결과 요약
    print("\n" + "=" * 60)
    print(f"스캔 완료 시간: {datetime.now()}")
    print(f"열린 포트 개수: {len(open_ports)}")
    if open_ports:
        print(f"열린 포트 목록: {open_ports}")
    print("=" * 60)

# 사용 예시
if __name__ == "__main__":
    target = "127.0.0.1"
    start = 1
    end = 1024  # Well-known ports
    
    scan_port_range(target, start, end)

import socket
import threading
from queue import Queue
from datetime import datetime

# 전역 변수
print_lock = threading.Lock()
open_ports = []

def port_scanner(target_ip, port):
    """
    개별 포트를 스캔하는 함수 (스레드에서 실행)
    """
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(1)
        
        result = sock.connect_ex((target_ip, port))
        
        if result == 0:
            with print_lock:
                try:
                    service = socket.getservbyport(port)
                except:
                    service = "Unknown"
                
                print(f"[+] 포트 {port:5d} : OPEN  ({service})")
                open_ports.append(port)
        
        sock.close()
        
    except:
        pass

def threader(target_ip, port_queue):
    """
    큐에서 포트를 가져와서 스캔하는 워커 함수
    """
    while True:
        port = port_queue.get()
        if port is None:
            break
        port_scanner(target_ip, port)
        port_queue.task_done()

def scan_ports_threaded(target_host, start_port, end_port, num_threads=100):
    """
    멀티스레드를 사용한 포트 스캔
    
    Args:
        target_host: 스캔할 호스트
        start_port: 시작 포트
        end_port: 종료 포트
        num_threads: 사용할 스레드 개수 (기본 100)
    """
    print("=" * 70)
    print(f"🔍 멀티스레드 포트 스캐너")
    print("=" * 70)
    print(f"대상 호스트: {target_host}")
    print(f"포트 범위: {start_port} - {end_port}")
    print(f"스레드 개수: {num_threads}")
    print(f"시작 시간: {datetime.now()}")
    print("=" * 70 + "\n")
    
    try:
        target_ip = socket.gethostbyname(target_host)
        print(f"[*] IP 주소: {target_ip}\n")
    except socket.gaierror:
        print(f"[!] 호스트를 찾을 수 없습니다: {target_host}")
        return
    
    # 큐 생성 및 포트 추가
    port_queue = Queue()
    for port in range(start_port, end_port + 1):
        port_queue.put(port)
    
    # 스레드 생성 및 시작
    threads = []
    for _ in range(num_threads):
        thread = threading.Thread(target=threader, args=(target_ip, port_queue))
        thread.daemon = True
        thread.start()
        threads.append(thread)
    
    # 모든 작업이 완료될 때까지 대기
    port_queue.join()
    
    # 스레드 종료
    for _ in range(num_threads):
        port_queue.put(None)
    for thread in threads:
        thread.join()
    
    # 결과 출력
    print("\n" + "=" * 70)
    print(f"✅ 스캔 완료!")
    print(f"종료 시간: {datetime.now()}")
    print(f"열린 포트 개수: {len(open_ports)}")
    if open_ports:
        open_ports.sort()
        print(f"열린 포트: {open_ports}")
    print("=" * 70)

# 사용 예시
if __name__ == "__main__":
    target = "scanme.nmap.org"  # 테스트용 공개 서버
    scan_ports_threaded(target, 1, 1000, num_threads=200)

from scapy.all import *
import sys

def syn_scan(target_ip, port_range):
    """
    SYN 스캔 (Half-Open Scan) 구현
    
    Args:
        target_ip: 대상 IP 주소
        port_range: 스캔할 포트 리스트
    """
    print("=" * 70)
    print("🎯 SYN 스캔 (Stealth Scan)")
    print("=" * 70)
    print(f"대상: {target_ip}")
    print(f"포트 개수: {len(port_range)}")
    print("=" * 70 + "\n")
    
    open_ports = []
    closed_ports = []
    filtered_ports = []
    
    for port in port_range:
        # SYN 패킷 생성
        src_port = RandShort()  # 랜덤 소스 포트
        
        # IP 레이어 + TCP 레이어 (SYN 플래그)
        packet = IP(dst=target_ip) / TCP(sport=src_port, dport=port, flags="S")
        
        # 패킷 전송 및 응답 대기
        response = sr1(packet, timeout=1, verbose=0)
        
        if response is None:
            # 응답 없음 = 필터링됨
            filtered_ports.append(port)
            print(f"[?] 포트 {port:5d} : FILTERED")
            
        elif response.haslayer(TCP):
            if response[TCP].flags == 0x12:  # SYN-ACK
                # 포트 열림
                open_ports.append(port)
                print(f"[+] 포트 {port:5d} : OPEN ✅")
                
                # RST 패킷 전송하여 연결 종료
                rst_packet = IP(dst=target_ip) / TCP(sport=src_port, dport=port, flags="R")
                send(rst_packet, verbose=0)
                
            elif response[TCP].flags == 0x14:  # RST-ACK
                # 포트 닫힘
                closed_ports.append(port)
                print(f"[-] 포트 {port:5d} : CLOSED")
        
        elif response.haslayer(ICMP):
            # ICMP 에러 = 필터링됨
            filtered_ports.append(port)
            print(f"[?] 포트 {port:5d} : FILTERED (ICMP)")
    
    # 결과 요약
    print("\n" + "=" * 70)
    print("📊 스캔 결과 요약")
    print("=" * 70)
    print(f"열린 포트: {len(open_ports)} 개")
    if open_ports:
        print(f"  → {open_ports}")
    print(f"닫힌 포트: {len(closed_ports)} 개")
    print(f"필터링된 포트: {len(filtered_ports)} 개")
    print("=" * 70)

# 사용 예시
if __name__ == "__main__":
    # 관리자 권한 확인
    if os.geteuid() != 0:
        print("[!] 이 스크립트는 root 권한이 필요합니다!")
        print("    sudo python3 syn_scanner.py")
        sys.exit(1)
    
    target = "192.168.1.1"
    ports = [20, 21, 22, 23, 25, 80, 443, 3306, 8080]
    
    syn_scan(target, ports)

import socket
import re

def grab_banner(ip, port, timeout=2):
    """
    배너 그래빙을 통한 서비스 정보 수집
    
    Args:
        ip: 대상 IP
        port: 대상 포트
        timeout: 타임아웃 (초)
    
    Returns:
        서비스 배너 문자열 또는 None
    """
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(timeout)
        sock.connect((ip, port))
        
        # HTTP 요청 전송 (웹 서버인 경우)
        if port in [80, 443, 8080, 8443]:
            request = b"GET / HTTP/1.1\r\nHost: " + ip.encode() + b"\r\n\r\n"
            sock.send(request)
        else:
            # 일반적인 경우 빈 데이터 전송
            sock.send(b"\r\n")
        
        # 응답 수신
        banner = sock.recv(1024).decode('utf-8', errors='ignore').strip()
        sock.close()
        
        return banner
        
    except:
        return None

def detect_service_version(ip, port):
    """
    서비스 버전 탐지
    """
    banner = grab_banner(ip, port)
    
    if not banner:
        return "Unknown", "Unknown"
    
    # 서비스 타입 및 버전 파싱
    service_patterns = {
        'SSH': r'SSH-[\d\.]+-(\S+)',
        'FTP': r'220.*?(\S+)\s+FTP',
        'HTTP': r'Server:\s*(\S+)',
        'MySQL': r'(\d+\.\d+\.\d+)-MySQL',
        'Apache': r'Apache/([\d\.]+)',
        'nginx': r'nginx/([\d\.]+)',
        'Microsoft-IIS': r'Microsoft-IIS/([\d\.]+)',
    }
    
    service_name = "Unknown"
    version = "Unknown"
    
    for service, pattern in service_patterns.items():
        match = re.search(pattern, banner, re.IGNORECASE)
        if match:
            service_name = service
            version = match.group(1)
            break
    
    return service_name, version, banner[:100]

def advanced_port_scan(target_ip, ports):
    """
    서비스 버전 탐지 기능이 포함된 포트 스캔
    """
    print("=" * 80)
    print("🔍 고급 포트 스캐너 (서비스 버전 탐지)")
    print("=" * 80)
    print(f"대상: {target_ip}")
    print("=" * 80 + "\n")
    
    results = []
    
    for port in ports:
        try:
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.settimeout(1)
            
            result = sock.connect_ex((target_ip, port))
            
            if result == 0:
                # 포트가 열려있으면 서비스 정보 수집
                service_name, version, banner = detect_service_version(target_ip, port)
                
                results.append({
                    'port': port,
                    'service': service_name,
                    'version': version,
                    'banner': banner
                })
                
                print(f"[+] 포트 {port:5d} : OPEN")
                print(f"    서비스: {service_name}")
                print(f"    버전: {version}")
                if banner and banner != "Unknown":
                    print(f"    배너: {banner[:80]}...")
                print()
            
            sock.close()
            
        except Exception as e:
            pass
    
    # 결과 테이블 출력
    if results:
        print("\n" + "=" * 80)
        print("📊 탐지된 서비스 요약")
        print("=" * 80)
        print(f"{'포트':<10} {'서비스':<20} {'버전':<30}")
        print("-" * 80)
        for r in results:
            print(f"{r['port']:<10} {r['service']:<20} {r['version']:<30}")
        print("=" * 80)
    
    return results

# 사용 예시
if __name__ == "__main__":
    target = "scanme.nmap.org"
    common_ports = [21, 22, 23, 25, 80, 110, 143, 443, 3306, 3389, 8080]
    
    advanced_port_scan(target, common_ports)

import socket
import threading
from queue import Queue
from datetime import datetime
import json
import argparse

class NetworkSecurityScanner:
    """
    종합 네트워크 보안 스캐너 클래스
    """
    
    def __init__(self, target, ports=None, threads=100):
        self.target = target
        self.target_ip = None
        self.ports = ports if ports else range(1, 1025)
        self.threads = threads
        self.open_ports = []
        self.services = {}
        self.vulnerabilities = []
        self.print_lock = threading.Lock()
        
        # 알려진 취약한 서비스/버전
        self.vulnerable_services = {
            'OpenSSH': ['7.2', '7.3', '7.4'],
            'Apache': ['2.4.49', '2.4.50'],
            'nginx': ['1.6.2', '1.6.3'],
            'vsftpd': ['2.3.4'],
        }
    
    def resolve_target(self):
        """대상 호스트를 IP로 변환"""
        try:
            self.target_ip = socket.gethostbyname(self.target)
            return True
        except socket.gaierror:
            print(f"[!] 호스트를 찾을 수 없습니다: {self.target}")
            return False
    
    def scan_port(self, port):
        """개별 포트 스캔"""
        try:
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.settimeout(1)
            
            result = sock.connect_ex((self.target_ip, port))
            
            if result == 0:
                with self.print_lock:
                    self.open_ports.append(port)
                    print(f"[+] 포트 {port} 열림")
            
            sock.close()
            
        except:
            pass
    
    def worker(self, queue):
        """스레드 워커"""
        while True:
            port = queue.get()
            if port is None:
                break
            self.scan_port(port)
            queue.task_done()
    
    def run_port_scan(self):
        """멀티스레드 포트 스캔 실행"""
        print("\n" + "=" * 70)
        print("🔍 1단계: 포트 스캔")
        print("=" * 70)
        
        queue = Queue()
        for port in self.ports:
            queue.put(port)
        
        threads = []
        for _ in range(self.threads):
            thread = threading.Thread(target=self.worker, args=(queue,))
            thread.daemon = True
            thread.start()
            threads.append(thread)
        
        queue.join()
        
        for _ in range(self.threads):
            queue.put(None)
        for thread in threads:
            thread.join()
        
        self.open_ports.sort()
        print(f"\n✅ 열린 포트 {len(self.open_ports)}개 발견")
    
    def detect_services(self):
        """서비스 탐지"""
        print("\n" + "=" * 70)
        print("🔍 2단계: 서비스 탐지")
        print("=" * 70)
        
        for port in self.open_ports:
            try:
                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                sock.settimeout(2)
                sock.connect((self.target_ip, port))
                
                # 배너 수신 시도
                sock.send(b"\r\n")
                banner = sock.recv(1024).decode('utf-8', errors='ignore').strip()
                
                if banner:
                    self.services[port] = banner[:100]
                    print(f"[+] 포트 {port}: {banner[:80]}")
                else:
                    # 기본 서비스 이름
                    try:
                        service = socket.getservbyport(port)
                        self.services[port] = service
                        print(f"[+] 포트 {port}: {service}")
                    except:
                        self.services[port] = "Unknown"
                
                sock.close()
                
            except:
                try:
                    service = socket.getservbyport(port)
                    self.services[port] = service
                except:
                    self.services[port] = "Unknown"
    
    def check_vulnerabilities(self):
        """취약점 체크"""
        print("\n" + "=" * 70)
        print("🔍 3단계: 취약점 분석")
        print("=" * 70)
        
        for port, banner in self.services.items():
            for service, vuln_versions in self.vulnerable_services.items():
                if service.lower() in banner.lower():
                    for version in vuln_versions:
                        if version in banner:
                            vuln = {
                                'port': port,
                                'service': service,
                                'version': version,
                                'severity': 'HIGH',
                                'description': f'{service} {version}에 알려진 취약점 존재'
                            }
                            self.vulnerabilities.append(vuln)
                            print(f"[!] 취약점 발견: 포트 {port} - {service} {version}")
        
        # 일반적인 보안 체크
        if 23 in self.open_ports:
            self.vulnerabilities.append({
                'port': 23,
                'service': 'Telnet',
                'severity': 'MEDIUM',
                'description': 'Telnet은 암호화되지 않은 프로토콜입니다. SSH 사용을 권장합니다.'
            })
            print(f"[!] 보안 권고: 포트 23 (Telnet) - 암호화되지 않은 통신")
        
        if 21 in self.open_ports:
            self.vulnerabilities.append({
                'port': 21,
                'service': 'FTP',
                'severity': 'MEDIUM',
                'description': 'FTP는 암호화되지 않은 프로토콜입니다. SFTP 사용을 권장합니다.'
            })
            print(f"[!] 보안 권고: 포트 21 (FTP) - 암호화되지 않은 통신")
        
        if not self.vulnerabilities:
            print("✅ 알려진 취약점이 발견되지 않았습니다.")
    
    def generate_report(self, filename=None):
        """보고서 생성"""
        print("\n" + "=" * 70)
        print("📄 4단계: 보고서 생성")
        print("=" * 70)
        
        report = {
            'scan_info': {
                'target': self.target,
                'target_ip': self.target_ip,
                'scan_time': datetime.now().isoformat(),
                'ports_scanned': len(list(self.ports)),
            },
            'results': {
                'open_ports': self.open_ports,
                'services': self.services,
                'vulnerabilities': self.vulnerabilities,
            },
            'summary': {
                'total_open_ports': len(self.open_ports),
                'total_vulnerabilities': len(self.vulnerabilities),
                'risk_level': self.calculate_risk_level(),
            }
        }
        
        # 콘솔 출력
        print(f"\n대상: {self.target} ({self.target_ip})")
        print(f"스캔 시간: {report['scan_info']['scan_time']}")
        print(f"열린 포트: {len(self.open_ports)}개")
        print(f"발견된 취약점: {len(self.vulnerabilities)}개")
        print(f"위험도: {report['summary']['risk_level']}")
        
        # JSON 파일로 저장
        if filename:
            with open(filename, 'w', encoding='utf-8') as f:
                json.dump(report, f, indent=2, ensure_ascii=False)
            print(f"\n✅ 보고서가 저장되었습니다: {filename}")
        
        return report
    
    def calculate_risk_level(self):
        """위험도 계산"""
        high_count = sum(1 for v in self.vulnerabilities if v.get('severity') == 'HIGH')
        medium_count = sum(1 for v in self.vulnerabilities if v.get('severity') == 'MEDIUM')
        
        if high_count > 0:
            return "HIGH"
        elif medium_count > 2:
            return "MEDIUM"
        elif medium_count > 0:
            return "LOW"
        else:
            return "SAFE"
    
    def run_full_scan(self):
        """전체 스캔 실행"""
        print("=" * 70)
        print("🛡️  네트워크 보안 스캐너")
        print("=" * 70)
        print(f"대상: {self.target}")
        print(f"시작 시간: {datetime.now()}")
        print("=" * 70)
        
        if not self.resolve_target():
            return None
        
        print(f"IP 주소: {self.target_ip}")
        
        # 1. 포트 스캔
        self.run_port_scan()
        
        # 2. 서비스 탐지
        if self.open_ports:
            self.detect_services()
        
        # 3. 취약점 체크
        if self.services:
            self.check_vulnerabilities()
        
        # 4. 보고서 생성
        report = self.generate_report(f"scan_report_{self.target}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json")
        
        print("\n" + "=" * 70)
        print("✅ 스캔 완료!")
        print("=" * 70)
        
        return report

# 메인 실행 부분
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='네트워크 보안 스캐너')
    parser.add_argument('target', help='스캔할 대상 호스트')
    parser.add_argument('-p', '--ports', help='포트 범위 (예: 1-1000)', default='1-1024')
    parser.add_argument('-t', '--threads', type=int, help='스레드 개수', default=100)
    
    args = parser.parse_args()
    
    # 포트 범위 파싱
    if '-' in args.ports:
        start, end = map(int, args.ports.split('-'))
        ports = range(start, end + 1)
    else:
        ports = [int(p) for p in args.ports.split(',')]
    
    # 스캐너 실행
    scanner = NetworkSecurityScanner(args.target, ports, args.threads)
    scanner.run_full_scan()

import tkinter as tk
from tkinter import ttk, scrolledtext, messagebox
import socket
import threading
from datetime import datetime

class PortScannerGUI:
    def __init__(self, root):
        self.root = root
        self.root.title("🔍 포트 스캐너")
        self.root.geometry("700x600")
        self.root.resizable(False, False)
        
        self.scanning = False
        self.setup_ui()
    
    def setup_ui(self):
        # 스타일 설정
        style = ttk.Style()
        style.theme_use('clam')
        
        # 메인 프레임
        main_frame = ttk.Frame(self.root, padding="10")
        main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        
        # 타이틀
        title_label = tk.Label(main_frame, text="🔍 포트 스캐너", 
                              font=("Arial", 18, "bold"), fg="#667eea")
        title_label.grid(row=0, column=0, columnspan=3, pady=10)
        
        # 대상 호스트 입력
        ttk.Label(main_frame, text="대상 호스트:", font=("Arial", 10)).grid(row=1, column=0, sticky=tk.W, pady=5)
        self.host_entry = ttk.Entry(main_frame, width=40, font=("Arial", 10))
        self.host_entry.grid(row=1, column=1, columnspan=2, sticky=(tk.W, tk.E), pady=5)
        self.host_entry.insert(0, "127.0.0.1")
        
        # 포트 범위 입력
        ttk.Label(main_frame, text="시작 포트:", font=("Arial", 10)).grid(row=2, column=0, sticky=tk.W, pady=5)
        self.start_port_entry = ttk.Entry(main_frame, width=15, font=("Arial", 10))
        self.start_port_entry.grid(row=2, column=1, sticky=tk.W, pady=5)
        self.start_port_entry.insert(0, "1")
        
        ttk.Label(main_frame, text="종료 포트:", font=("Arial", 10)).grid(row=3, column=0, sticky=tk.W, pady=5)
        self.end_port_entry = ttk.Entry(main_frame, width=15, font=("Arial", 10))
        self.end_port_entry.grid(row=3, column=1, sticky=tk.W, pady=5)
        self.end_port_entry.insert(0, "1000")
        
        # 스레드 개수
        ttk.Label(main_frame, text="스레드 개수:", font=("Arial", 10)).grid(row=4, column=0, sticky=tk.W, pady=5)
        self.threads_entry = ttk.Entry(main_frame, width=15, font=("Arial", 10))
        self.threads_entry.grid(row=4, column=1, sticky=tk.W, pady=5)
        self.threads_entry.insert(0, "100")
        
        # 버튼 프레임
        button_frame = ttk.Frame(main_frame)
        button_frame.grid(row=5, column=0, columnspan=3, pady=15)
        
        self.scan_button = tk.Button(button_frame, text="🚀 스캔 시작", 
                                     command=self.start_scan, bg="#667eea", fg="white",
                                     font=("Arial", 11, "bold"), width=15, height=2)
        self.scan_button.pack(side=tk.LEFT, padx=5)
        
        self.stop_button = tk.Button(button_frame, text="⏹ 중지", 
                                     command=self.stop_scan, bg="#ef4444", fg="white",
                                     font=("Arial", 11, "bold"), width=15, height=2, state=tk.DISABLED)
        self.stop_button.pack(side=tk.LEFT, padx=5)
        
        # 진행 상태
        ttk.Label(main_frame, text="진행 상태:", font=("Arial", 10)).grid(row=6, column=0, sticky=tk.W, pady=5)
        self.progress = ttk.Progressbar(main_frame, length=400, mode='determinate')
        self.progress.grid(row=6, column=1, columnspan=2, sticky=(tk.W, tk.E), pady=5)
        
        self.status_label = ttk.Label(main_frame, text="대기 중...", font=("Arial", 9))
        self.status_label.grid(row=7, column=0, columnspan=3, pady=5)
        
        # 결과 출력 영역
        ttk.Label(main_frame, text="스캔 결과:", font=("Arial", 10, "bold")).grid(row=8, column=0, sticky=tk.W, pady=5)
        
        self.result_text = scrolledtext.ScrolledText(main_frame, width=80, height=20, 
                                                     font=("Courier New", 9))
        self.result_text.grid(row=9, column=0, columnspan=3, pady=5)
        
        # 태그 설정 (색상)
        self.result_text.tag_config("open", foreground="#10b981")
        self.result_text.tag_config("closed", foreground="#6b7280")
        self.result_text.tag_config("info", foreground="#667eea")
        self.result_text.tag_config("error", foreground="#ef4444")
    
    def log(self, message, tag="info"):
        """결과 창에 로그 출력"""
        self.result_text.insert(tk.END, message + "\n", tag)
        self.result_text.see(tk.END)
        self.root.update_idletasks()
    
    def start_scan(self):
        """스캔 시작"""
        if self.scanning:
            return
        
        # 입력 검증
        try:
            host = self.host_entry.get().strip()
            start_port = int(self.start_port_entry.get())
            end_port = int(self.end_port_entry.get())
            num_threads = int(self.threads_entry.get())
            
            if not host:
                raise ValueError("호스트를 입력하세요")
            if start_port < 1 or end_port > 65535 or start_port > end_port:
                raise ValueError("올바른 포트 범위를 입력하세요 (1-65535)")
            if num_threads < 1 or num_threads > 500:
                raise ValueError("스레드 개수는 1-500 사이여야 합니다")
                
        except ValueError as e:
            messagebox.showerror("입력 오류", str(e))
            return
        
        # UI 상태 변경
        self.scanning = True
        self.scan_button.config(state=tk.DISABLED)
        self.stop_button.config(state=tk.NORMAL)
        self.result_text.delete(1.0, tk.END)
        self.progress['value'] = 0
        
        # 스캔 스레드 시작
        scan_thread = threading.Thread(target=self.run_scan, 
                                       args=(host, start_port, end_port, num_threads))
        scan_thread.daemon = True
        scan_thread.start()
    
    def stop_scan(self):
        """스캔 중지"""
        self.scanning = False
        self.scan_button.config(state=tk.NORMAL)
        self.stop_button.config(state=tk.DISABLED)
        self.status_label.config(text="스캔이 중지되었습니다.")
        self.log("⏹ 사용자에 의해 스캔이 중지되었습니다.", "error")
    
    def run_scan(self, host, start_port, end_port, num_threads):
        """실제 스캔 실행"""
        self.log("=" * 70, "info")
        self.log(f"🔍 포트 스캔 시작", "info")
        self.log("=" * 70, "info")
        self.log(f"대상: {host}", "info")
        self.log(f"포트 범위: {start_port} - {end_port}", "info")
        self.log(f"시작 시간: {datetime.now()}", "info")
        self.log("=" * 70 + "\n", "info")
        
        # IP 확인
        try:
            target_ip = socket.gethostbyname(host)
            self.log(f"IP 주소: {target_ip}\n", "info")
        except socket.gaierror:
            self.log(f"호스트를 찾을 수 없습니다: {host}", "error")
            self.stop_scan()
            return
        
        # 포트 스캔
        total_ports = end_port - start_port + 1
        scanned_ports = 0
        open_ports = []
        
        from queue import Queue
        
        def scan_port(port):
            nonlocal scanned_ports
            if not self.scanning:
                return
            
            try:
                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                sock.settimeout(0.5)
                result = sock.connect_ex((target_ip, port))
                
                if result == 0:
                    try:
                        service = socket.getservbyport(port)
                    except:
                        service = "Unknown"
                    
                    open_ports.append(port)
                    self.log(f"[+] 포트 {port:5d} : OPEN  ({service})", "open")
                
                sock.close()
                
            except:
                pass
            finally:
                scanned_ports += 1
                progress = (scanned_ports / total_ports) * 100
                self.progress['value'] = progress
                self.status_label.config(text=f"스캔 중... {scanned_ports}/{total_ports} 포트")
        
        def worker(queue):
            while self.scanning:
                port = queue.get()
                if port is None:
                    break
                scan_port(port)
                queue.task_done()
        
        # 큐 생성 및 스레드 시작
        queue = Queue()
        for port in range(start_port, end_port + 1):
            queue.put(port)
        
        threads = []
        for _ in range(num_threads):
            thread = threading.Thread(target=worker, args=(queue,))
            thread.daemon = True
            thread.start()
            threads.append(thread)
        
        queue.join()
        
        for _ in range(num_threads):
            queue.put(None)
        for thread in threads:
            thread.join()
        
        # 결과 요약
        self.log("\n" + "=" * 70, "info")
        self.log("✅ 스캔 완료!", "info")
        self.log("=" * 70, "info")
        self.log(f"종료 시간: {datetime.now()}", "info")
        self.log(f"열린 포트 개수: {len(open_ports)}", "info")
        if open_ports:
            self.log(f"열린 포트: {open_ports}", "open")
        self.log("=" * 70, "info")
        
        # UI 상태 복원
        self.scanning = False
        self.scan_button.config(state=tk.NORMAL)
        self.stop_button.config(state=tk.DISABLED)
        self.status_label.config(text="스캔 완료!")
        self.progress['value'] = 100

# 메인 실행
if __name__ == "__main__":
    root = tk.Tk()
    app = PortScannerGUI(root)
    root.mainloop()

# Linux에서 서비스 중지 및 비활성화
sudo systemctl stop telnet.service
sudo systemctl disable telnet.service

# 특정 포트 방화벽 차단 (iptables)
sudo iptables -A INPUT -p tcp --dport 23 -j DROP

# 방화벽 규칙 저장
sudo iptables-save > /etc/iptables/rules.v4

# UFW (Ubuntu Firewall) 사용 예시
# 방화벽 활성화
sudo ufw enable

# 기본 정책: 모든 incoming 차단, outgoing 허용
sudo ufw default deny incoming
sudo ufw default allow outgoing

# 필요한 포트만 허용
sudo ufw allow 22/tcp    # SSH
sudo ufw allow 80/tcp    # HTTP
sudo ufw allow 443/tcp   # HTTPS

# 특정 IP에서만 접근 허용
sudo ufw allow from 192.168.1.100 to any port 22

# 상태 확인
sudo ufw status verbose

# knockd 설치 (Ubuntu/Debian)
sudo apt-get install knockd

# /etc/knockd.conf 설정
[options]
    UseSyslog

[openSSH]
    sequence    = 7000,8000,9000
    seq_timeout = 5
    command     = /sbin/iptables -A INPUT -s %IP% -p tcp --dport 22 -j ACCEPT
    tcpflags    = syn

[closeSSH]
    sequence    = 9000,8000,7000
    seq_timeout = 5
    command     = /sbin/iptables -D INPUT -s %IP% -p tcp --dport 22 -j ACCEPT
    tcpflags    = syn

# knockd 시작
sudo systemctl start knockd
sudo systemctl enable knockd

# 클라이언트에서 포트 노킹
knock server_ip 7000 8000 9000
ssh user@server_ip

# Fail2Ban 설치
sudo apt-get install fail2ban

# /etc/fail2ban/jail.local 설정
[DEFAULT]
bantime = 3600
findtime = 600
maxretry = 5

[sshd]
enabled = true
port = ssh
logpath = /var/log/auth.log
maxretry = 3

# Fail2Ban 시작
sudo systemctl start fail2ban
sudo systemctl enable fail2ban

# 상태 확인
sudo fail2ban-client status
sudo fail2ban-client status sshd

import subprocess
import socket

class SecurityChecker:
    """보안 점검 자동화 클래스"""
    
    def __init__(self):
        self.results = []
        self.score = 0
        self.max_score = 0
    
    def check_open_ports(self, dangerous_ports=[21, 23, 135, 139, 445]):
        """위험한 포트 열림 여부 확인"""
        print("\n[*] 위험한 포트 점검 중...")
        
        found_dangerous = []
        for port in dangerous_ports:
            try:
                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                sock.settimeout(0.5)
                result = sock.connect_ex(('127.0.0.1', port))
                
                if result == 0:
                    found_dangerous.append(port)
                    print(f"[!] 위험: 포트 {port} 열림")
                
                sock.close()
            except:
                pass
        
        self.max_score += 10
        if not found_dangerous:
            self.score += 10
            self.results.append(("위험한 포트", "PASS", "위험한 포트가 열려있지 않음"))
        else:
            self.results.append(("위험한 포트", "FAIL", f"열린 위험 포트: {found_dangerous}"))
    
    def check_firewall(self):
        """방화벽 활성화 여부 확인"""
        print("\n[*] 방화벽 상태 점검 중...")
        
        try:
            # UFW 상태 확인
            result = subprocess.run(['sudo', 'ufw', 'status'], 
                                  capture_output=True, text=True, timeout=5)
            
            self.max_score += 10
            if 'Status: active' in result.stdout:
                self.score += 10
                self.results.append(("방화벽", "PASS", "방화벽이 활성화되어 있음"))
                print("[+] 방화벽 활성화됨")
            else:
                self.results.append(("방화벽", "FAIL", "방화벽이 비활성화되어 있음"))
                print("[!] 방화벽 비활성화됨")
        except:
            self.max_score += 10
            self.results.append(("방화벽", "ERROR", "방화벽 상태 확인 불가"))
            print("[!] 방화벽 상태 확인 실패")
    
    def check_ssh_config(self):
        """SSH 설정 점검"""
        print("\n[*] SSH 설정 점검 중...")
        
        try:
            with open('/etc/ssh/sshd_config', 'r') as f:
                config = f.read()
            
            # Root 로그인 체크
            self.max_score += 5
            if 'PermitRootLogin no' in config or 'PermitRootLogin prohibit-password' in config:
                self.score += 5
                self.results.append(("SSH Root 로그인", "PASS", "Root 직접 로그인 차단됨"))
                print("[+] Root 로그인 차단됨")
            else:
                self.results.append(("SSH Root 로그인", "FAIL", "Root 로그인이 허용되어 있음"))
                print("[!] Root 로그인 허용됨")
            
            # 비밀번호 인증 체크
            self.max_score += 5
            if 'PasswordAuthentication no' in config:
                self.score += 5
                self.results.append(("SSH 비밀번호 인증", "PASS", "비밀번호 인증 비활성화됨"))
                print("[+] 비밀번호 인증 비활성화됨")
            else:
                self.results.append(("SSH 비밀번호 인증", "WARN", "비밀번호 인증이 활성화되어 있음"))
                print("[!] 비밀번호 인증 활성화됨")
                
        except FileNotFoundError:
            self.max_score += 10
            self.results.append(("SSH 설정", "ERROR", "SSH 설정 파일을 찾을 수 없음"))
            print("[!] SSH 설정 파일 없음")
        except PermissionError:
            self.max_score += 10
            self.results.append(("SSH 설정", "ERROR", "권한 부족 (sudo 필요)"))
            print("[!] 권한 부족")
    
    def check_updates(self):
        """시스템 업데이트 상태 확인"""
        print("\n[*] 시스템 업데이트 상태 점검 중...")
        
        try:
            # apt 업데이트 확인 (Ubuntu/Debian)
            result = subprocess.run(['apt', 'list', '--upgradable'], 
                                  capture_output=True, text=True, timeout=10)
            
            upgradable = result.stdout.count('\n') - 1
            
            self.max_score += 10
            if upgradable == 0:
                self.score += 10
                self.results.append(("시스템 업데이트", "PASS", "모든 패키지가 최신 상태"))
                print("[+] 시스템 최신 상태")
            elif upgradable < 10:
                self.score += 5
                self.results.append(("시스템 업데이트", "WARN", f"{upgradable}개 업데이트 가능"))
                print(f"[!] {upgradable}개 업데이트 필요")
            else:
                self.results.append(("시스템 업데이트", "FAIL", f"{upgradable}개 업데이트 필요"))
                print(f"[!] {upgradable}개 업데이트 필요")
        except:
            self.max_score += 10
            self.results.append(("시스템 업데이트", "ERROR", "업데이트 상태 확인 불가"))
            print("[!] 업데이트 상태 확인 실패")
    
    def generate_report(self):
        """보안 점검 보고서 생성"""
        print("\n" + "=" * 70)
        print("📊 보안 점검 보고서")
        print("=" * 70)
        
        for item, status, detail in self.results:
            status_symbol = {
                "PASS": "✅",
                "FAIL": "❌",
                "WARN": "⚠️",
                "ERROR": "❓"
            }.get(status, "")
            
            print(f"{status_symbol} {item:20s} : {status:6s} - {detail}")
        
        print("\n" + "=" * 70)
        percentage = (self.score / self.max_score * 100) if self.max_score > 0 else 0
        print(f"보안 점수: {self.score}/{self.max_score} ({percentage:.1f}%)")
        
        if percentage >= 90:
            grade = "A (매우 안전)"
        elif percentage >= 70:
            grade = "B (안전)"
        elif percentage >= 50:
            grade = "C (보통)"
        else:
            grade = "D (위험)"
        
        print(f"보안 등급: {grade}")
        print("=" * 70)
    
    def run_all_checks(self):
        """모든 점검 실행"""
        print("🛡️  보안 점검 시작")
        print("=" * 70)
        
        self.check_open_ports()
        self.check_firewall()
        self.check_ssh_config()
        self.check_updates()
        
        self.generate_report()

# 실행
if __name__ == "__main__":
    checker = SecurityChecker()
    checker.run_all_checks()

# Nmap 설치
sudo apt-get install nmap  # Ubuntu/Debian
sudo yum install nmap      # CentOS/RHEL

# 기본 스캔
nmap 192.168.1.1

# 특정 포트 스캔
nmap -p 80,443 192.168.1.1
nmap -p 1-1000 192.168.1.1

# SYN 스캔 (빠르고 스텔스)
sudo nmap -sS 192.168.1.1

# 서비스 버전 탐지
nmap -sV 192.168.1.1

# OS 탐지
sudo nmap -O 192.168.1.1

# 공격적 스캔 (모든 기능)
sudo nmap -A 192.168.1.1

# 취약점 스캔
nmap --script vuln 192.168.1.1

# 결과를 파일로 저장
nmap -oN output.txt 192.168.1.1
nmap -oX output.xml 192.168.1.1

# 여러 호스트 스캔
nmap 192.168.1.1-254
nmap 192.168.1.0/24

import nmap

def advanced_nmap_scan(target, ports='1-1000'):
    """
    Nmap을 사용한 고급 스캔
    """
    print("=" * 70)
    print("🔍 Nmap 스캔 시작")
    print("=" * 70)
    print(f"대상: {target}")
    print(f"포트: {ports}")
    print("=" * 70 + "\n")
    
    # Nmap 스캐너 객체 생성
    nm = nmap.PortScanner()
    
    # 스캔 실행 (-sV: 서비스 버전 탐지, -T4: 빠른 스캔)
    print("[*] 스캔 진행 중...\n")
    nm.scan(target, ports, arguments='-sV -T4')
    
    # 결과 출력
    for host in nm.all_hosts():
        print(f"호스트: {host} ({nm[host].hostname()})")
        print(f"상태: {nm[host].state()}\n")
        
        for proto in nm[host].all_protocols():
            print(f"프로토콜: {proto}")
            
            ports_list = nm[host][proto].keys()
            for port in sorted(ports_list):
                port_info = nm[host][proto][port]
                state = port_info['state']
                service = port_info['name']
                version = port_info.get('version', '')
                product = port_info.get('product', '')
                
                print(f"  포트 {port:5d} : {state:8s} | {service:15s} | {product} {version}")
        
        print("\n" + "=" * 70)
    
    return nm

def nmap_vulnerability_scan(target):
    """
    Nmap 취약점 스캔
    """
    print("\n🔍 취약점 스캔 시작")
    print("=" * 70)
    
    nm = nmap.PortScanner()
    
    # 취약점 스캔 스크립트 실행
    nm.scan(target, arguments='--script vuln')
    
    for host in nm.all_hosts():
        print(f"\n호스트: {host}")
        
        if 'hostscript' in nm[host]:
            for script in nm[host]['hostscript']:
                print(f"\n스크립트: {script['id']}")
                print(f"결과:\n{script['output']}")
    
    print("=" * 70)

# 사용 예시
if __name__ == "__main__":
    target = "scanme.nmap.org"
    
    # 기본 스캔
    nm = advanced_nmap_scan(target, '22,80,443')
    
    # 취약점 스캔 (시간이 오래 걸림)
    # nmap_vulnerability_scan(target)

def pre_deployment_check(server_ip):
    """
    배포 전 보안 점검
    """
    print("🚀 배포 전 보안 점검 시작")
    print("=" * 70)
    
    # 1. 전체 포트 스캔
    print("\n[1단계] 전체 포트 스캔")
    scanner = NetworkSecurityScanner(server_ip, range(1, 65536), threads=500)
    scanner.run_port_scan()
    
    # 2. 필수 포트만 열려있는지 확인
    required_ports = {80, 443}  # 웹 서버
    allowed_ports = {22, 80, 443}  # SSH, HTTP, HTTPS
    
    print("\n[2단계] 포트 정책 검증")
    unexpected_ports = set(scanner.open_ports) - allowed_ports
    
    if unexpected_ports:
        print(f"[!] 예상치 못한 포트 발견: {unexpected_ports}")
        print("    → 이 포트들을 닫거나 방화벽으로 차단하세요!")
    else:
        print("[+] 모든 포트가 정책에 부합합니다.")
    
    missing_ports = required_ports - set(scanner.open_ports)
    if missing_ports:
        print(f"[!] 필수 포트가 열려있지 않음: {missing_ports}")
    else:
        print("[+] 모든 필수 포트가 열려있습니다.")
    
    # 3. 서비스 버전 확인
    print("\n[3단계] 서비스 버전 확인")
    scanner.detect_services()
    
    # 4. 취약점 검사
    print("\n[4단계] 취약점 검사")
    scanner.check_vulnerabilities()
    
    # 5. 최종 판정
    print("\n" + "=" * 70)
    if not unexpected_ports and not missing_ports and not scanner.vulnerabilities:
        print("✅ 배포 승인: 보안 점검 통과!")
    else:
        print("❌ 배포 보류: 보안 이슈 해결 필요!")
    print("=" * 70)

# 실행
pre_deployment_check("192.168.1.100")

import json
from datetime import datetime
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

def scheduled_security_scan(targets, baseline_file='baseline.json'):
    """
    정기 보안 스캔 및 변화 감지
    """
    print("📅 정기 보안 스캔 시작")
    print(f"시간: {datetime.now()}")
    print("=" * 70)
    
    # 기준선 로드
    try:
        with open(baseline_file, 'r') as f:
            baseline = json.load(f)
    except FileNotFoundError:
        baseline = {}
        print("[*] 기준선 파일이 없습니다. 새로 생성합니다.")
    
    changes = []
    current_state = {}
    
    for target in targets:
        print(f"\n[*] {target} 스캔 중...")
        
        scanner = NetworkSecurityScanner(target, range(1, 1025))
        scanner.run_port_scan()
        scanner.detect_services()
        
        current_state[target] = {
            'open_ports': scanner.open_ports,
            'services': scanner.services,
            'scan_time': datetime.now().isoformat()
        }
        
        # 변화 감지
        if target in baseline:
            old_ports = set(baseline[target]['open_ports'])
            new_ports = set(scanner.open_ports)
            
            # 새로 열린 포트
            opened = new_ports - old_ports
            if opened:
                changes.append({
                    'target': target,
                    'type': 'NEW_PORTS',
                    'details': f"새로 열린 포트: {list(opened)}"
                })
                print(f"[!] 변화 감지: 새로 열린 포트 {opened}")
            
            # 닫힌 포트
            closed = old_ports - new_ports
            if closed:
                changes.append({
                    'target': target,
                    'type': 'CLOSED_PORTS',
                    'details': f"닫힌 포트: {list(closed)}"
                })
                print(f"[!] 변화 감지: 닫힌 포트 {closed}")
    
    # 현재 상태를 새로운 기준선으로 저장
    with open(baseline_file, 'w') as f:
        json.dump(current_state, f, indent=2)
    
    # 변화가 있으면 알림
    if changes:
        print("\n" + "=" * 70)
        print("⚠️  변화 감지됨!")
        print("=" * 70)
        for change in changes:
            print(f"대상: {change['target']}")
            print(f"유형: {change['type']}")
            print(f"상세: {change['details']}\n")
        
        # 이메일 알림 (선택사항)
        # send_alert_email(changes)
    else:
        print("\n✅ 변화 없음. 모든 시스템 정상.")
    
    return changes

def send_alert_email(changes):
    """
    변화 감지 시 이메일 알림
    """
    sender = "security@company.com"
    receiver = "admin@company.com"
    password = "your_password"
    
    msg = MIMEMultipart()
    msg['From'] = sender
    msg['To'] = receiver
    msg['Subject'] = f"[보안 알림] 네트워크 변화 감지 - {datetime.now().strftime('%Y-%m-%d')}"
    
    body = "네트워크 스캔 중 다음과 같은 변화가 감지되었습니다:\n\n"
    for change in changes:
        body += f"대상: {change['target']}\n"
        body += f"유형: {change['type']}\n"
        body += f"상세: {change['details']}\n\n"
    
    msg.attach(MIMEText(body, 'plain'))
    
    try:
        server = smtplib.SMTP('smtp.gmail.com', 587)
        server.starttls()
        server.login(sender, password)
        server.send_message(msg)
        server.quit()
        print("[+] 알림 이메일 전송 완료")
    except Exception as e:
        print(f"[!] 이메일 전송 실패: {e}")

# 실행 (cron으로 정기 실행)
targets = ['192.168.1.1', '192.168.1.100', '192.168.1.200']
scheduled_security_scan(targets)

import ipaddress
import concurrent.futures

def discover_network(network_cidr, output_file='network_inventory.json'):
    """
    네트워크 전체 스캔 및 인벤토리 구축
    """
    print(f"🌐 네트워크 탐색 시작: {network_cidr}")
    print("=" * 70)
    
    network = ipaddress.ip_network(network_cidr)
    total_hosts = network.num_addresses - 2  # 네트워크 주소와 브로드캐스트 제외
    
    print(f"스캔할 호스트 수: {total_hosts}")
    print("=" * 70 + "\n")
    
    inventory = {}
    active_hosts = []
    
    def ping_host(ip):
        """호스트 활성 여부 확인"""
        try:
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.settimeout(0.5)
            result = sock.connect_ex((str(ip), 80))  # HTTP 포트로 테스트
            sock.close()
            return str(ip) if result == 0 else None
        except:
            return None
    
    # 1단계: 활성 호스트 찾기
    print("[1단계] 활성 호스트 탐색 중...")
    with concurrent.futures.ThreadPoolExecutor(max_workers=100) as executor:
        results = executor.map(ping_host, network.hosts())
        active_hosts = [ip for ip in results if ip]
    
    print(f"[+] {len(active_hosts)}개의 활성 호스트 발견\n")
    
    # 2단계: 각 호스트 상세 스캔
    print("[2단계] 상세 스캔 진행 중...")
    for i, host in enumerate(active_hosts, 1):
        print(f"\n[{i}/{len(active_hosts)}] {host} 스캔 중...")
        
        scanner = NetworkSecurityScanner(host, range(1, 1025), threads=200)
        scanner.run_port_scan()
        scanner.detect_services()
        
        # 호스트 정보 수집
        try:
            hostname = socket.gethostbyaddr(host)[0]
        except:
            hostname = "Unknown"
        
        inventory[host] = {
            'hostname': hostname,
            'open_ports': scanner.open_ports,
            'services': scanner.services,
            'scan_time': datetime.now().isoformat(),
            'os_guess': guess_os(scanner.services)
        }
        
        print(f"  호스트명: {hostname}")
        print(f"  열린 포트: {len(scanner.open_ports)}개")
    
    # 3단계: 인벤토리 저장
    with open(output_file, 'w') as f:
        json.dump(inventory, f, indent=2)
    
    # 4단계: 요약 보고서
    print("\n" + "=" * 70)
    print("📊 네트워크 인벤토리 요약")
    print("=" * 70)
    print(f"총 호스트 수: {len(inventory)}")
    
    # 서비스별 통계
    service_count = {}
    for host_info in inventory.values():
        for service in host_info['services'].values():
            service_count[service] = service_count.get(service, 0) + 1
    
    print("\n주요 서비스:")
    for service, count in sorted(service_count.items(), key=lambda x: x[1], reverse=True)[:10]:
        print(f"  {service:20s} : {count}개 호스트")
    
    print(f"\n✅ 인벤토리가 저장되었습니다: {output_file}")
    print("=" * 70)
    
    return inventory

def guess_os(services):
    """서비스 정보로 OS 추측"""
    services_str = ' '.join(str(s).lower() for s in services.values())
    
    if 'microsoft' in services_str or 'windows' in services_str:
        return "Windows"
    elif 'apache' in services_str or 'nginx' in services_str or 'openssh' in services_str:
        return "Linux/Unix"
    elif 'cisco' in services_str:
        return "Cisco IOS"
    else:
        return "Unknown"

# 실행
discover_network('192.168.1.0/24')