# 우리 사무실 네트워크에 열린 서비스 점검: nmap으로 기기별 포트 표 만들고 줄이기

> Docker 사설 네트워크에 프린터, NAS, 공유기, 일반 PC를 흉내 낸 컨테이너를 띄우고, 자기 소유 대역만 nmap으로 점검해 기기별 열린 포트를 표로 정리합니다. telnet, 평문 FTP, 관리 화면을 우선순위로 읽고, 쓰지 않는 서비스를 끈 뒤 다시 점검해 6개가 3개로 줄어드는 것을 확인합니다.

- 주소: https://copyandrun.com/blog/home-office-network-nmap-open-services-check/
- 분야: 개인·소규모 사무실
- 발행일: 2026-11-02
- 태그: nmap, 포트 점검, 사무실 네트워크, telnet, FTP

작은 사무실 망에는 프린터, NAS, 공유기처럼 설치한 뒤 한 번도 열어 보지 않은 기기가 있고, 이런 기기는 쓰지 않는 서비스를 켠 채로 두는 경우가 많습니다. 이 글은 기기를 흉내 낸 컨테이너 네 개를 nmap으로 점검해 기기별로 어떤 포트가 열려 있는지 표로 만들고, 어떤 것부터 끌지 정하는 과정을 다룹니다.

**자기 소유이거나 점검 허락을 받은 망만 스캔합니다.** 허락 없이 남의 망, 회사 밖 장비, 공용 와이파이를 스캔하지 않습니다. 이 글의 점검 대상은 모두 제가 만든 Docker 사설 네트워크(192.168.88.0/24)이고, 실제 사무실 망에는 어떤 스캔도 하지 않았습니다. 기기 컨테이너는 포트에 짧은 응답만 돌려주는 연습용 흉내이며 실제 서비스가 아닙니다.

**실제 사무실의 프린터, NAS, IoT 기기는 스캔 중에 멈추거나 이상하게 동작할 수 있습니다.** 오래된 장비는 낯선 접속과 서비스 탐지 요청을 잘 처리하지 못하는 경우가 있습니다. 업무 시간 밖에 진행하고, 중요한 장비는 사용자와 담당자에게 미리 알리며, 처음에는 `-p 21,23,80,445,631`처럼 포트 범위를 좁혀서 시작합니다. 이 글에서는 그런 장비를 대상으로 실행해 보지 않았습니다.

Windows Git Bash에서 Docker Desktop으로 실행했습니다. Linux와 macOS에서도 같은 명령이 되도록 썼지만 실행해 보지는 않았습니다.

## 준비물

| 항목 | 확인한 값 |
|---|---|
| 실행 환경 | Docker 29.5.3(Windows Git Bash) |
| 점검 도구 | nmap 7.98, `instrumentisto/nmap` 이미지 |
| 기기 흉내 | `python:3.12-alpine` 기반 이미지 1개, 컨테이너 4개 |
| 표 만들기 | Python 3.12.10 (표준 라이브러리만 사용) |

작업 폴더의 파일은 아래와 같고 전체 내용은 글 끝의 `## 전체 코드`에 있습니다.

```
Dockerfile
device.py
lab_up.sh
scan.sh
scan_table.py
lab_down.sh
```

## 1. 연습 망 만들기

<!-- files: Dockerfile, device.py, lab_up.sh -->

`lab_up.sh before`는 전용 네트워크 `cr-p24-net`(192.168.88.0/24)을 만들고 기기 컨테이너를 고정 주소로 띄웁니다. 기기와 열어 두는 포트는 다음과 같습니다.

| 주소 | 기기 | 열린 포트 |
|---|---|---|
| 192.168.88.10 | 프린터 | 631(인쇄 서비스), 9100(직접 출력) |
| 192.168.88.20 | NAS | 21(FTP), 445(파일 공유) |
| 192.168.88.30 | 공유기 | 80(관리 화면), 23(telnet) |
| 192.168.88.40 | 일반 PC | 없음 |

```bash
sh lab_up.sh before
```

공유기 관리 화면만 호스트 127.0.0.1:18190에 연결해 브라우저로 볼 수 있게 했고, 나머지는 호스트에 열지 않습니다. 192.168.88.0/24는 흔한 가정용 공유기 대역이라 실제 사무실 대역과 겹칠 수 있습니다. 겹치면 `lab_up.sh`와 `scan.sh`의 주소를 다른 사설 대역으로 바꿉니다(이 PC에서는 172.16~172.30 대역을 다른 네트워크가 이미 써서 192.168.88.0/24로 정했습니다).

![전용 네트워크 192.168.88.0/24에 프린터, NAS, 공유기, PC 컨테이너가 고정 주소로 떠 있고 공유기만 127.0.0.1:18190에 연결된 것을 확인합니다.](https://copyandrun.com/img/home-office-network-nmap-open-services-check/01-lab-network.png)

공유기 관리 화면은 브라우저에서 `http://127.0.0.1:18190/`로 열립니다.

![공유기 흉내의 관리자 로그인 화면이 열려서 80번 포트가 관리 화면 용도로 열려 있음을 확인합니다.](https://copyandrun.com/img/home-office-network-nmap-open-services-check/04-router-admin-page.png)

## 2. 자기 대역만 점검하기

<!-- files: scan.sh -->

`scan.sh before`는 점검 컨테이너(192.168.88.50)에서 `192.168.88.10-40`만 스캔합니다. 쓴 옵션은 nmap 공식 문서(`https://nmap.org/book/man-briefoptions.html`)로 확인했습니다.

| 옵션 | 의미 |
|---|---|
| `-sT` | TCP 연결 스캔. 컨테이너에서 관리자 권한 없이도 됩니다 |
| `-sV` | 열린 포트의 서비스와 버전을 알아봅니다 |
| `-n` | 이름 조회를 끕니다 |
| `-oX -` | XML 결과를 표준 출력으로 보냅니다 |
| `-oG 파일` | 한 줄 형식(grepable) 결과를 파일에 저장합니다 |

범위를 `192.168.88.10-40`으로 좁힌 이유는 점검기와 Docker 게이트웨이를 빼기 위해서입니다. 포트는 지정하지 않아 기본 설정인 자주 쓰는 1000개 포트를 봅니다. 취약점 스크립트(NSE)는 쓰지 않았고 열린 포트와 서비스 이름만 봅니다.

```bash
sh scan.sh before
grep Ports scan-before.gnmap
```

```
저장: scan-before.xml, scan-before.gnmap
Host: 192.168.88.10 ()  Ports: 631/open/tcp//ipp//CUPS|2.4 IPP|2.1/, 9100/open/tcp//jetdirect?///
Host: 192.168.88.20 ()  Ports: 21/open/tcp//ftp//vsftpd 2.0.8 or later/, 445/open/tcp//tcpwrapped///
Host: 192.168.88.30 ()  Ports: 23/open/tcp//telnet///, 80/open/tcp//http//lab-httpd/
Host: 192.168.88.40 ()  Ports: 
```

실제 출력에는 각 줄 끝에 `Ignored State: closed (998)` 같은 닫힌 포트 개수가 붙습니다.

![한 줄 형식 결과에서 프린터 2개, NAS 2개, 공유기 2개가 열려 있고 192.168.88.40은 열린 포트가 없는 것을 확인합니다.](https://copyandrun.com/img/home-office-network-nmap-open-services-check/02-grepable-ports.png)

nmap 공식 문서는 grepable 형식을 더 이상 권장하지 않고(deprecated) 다른 프로그램과 연동할 때는 XML을 권장합니다. 그래서 표는 XML에서 만들고 grepable 파일은 눈으로 확인하는 용도로만 씁니다. 445번 포트가 `tcpwrapped`로 나온 것은 제 흉내 서버가 연결만 받고 아무 응답도 보내지 않기 때문입니다. 진짜 파일 공유 서버라면 서비스 이름이 다르게 나옵니다.

## 3. 기기별 표로 정리하기

<!-- files: scan_table.py -->

`scan_table.py`는 XML을 읽어 기기별 열린 포트와 점검 우선순위를 표로 출력합니다. 기기 이름과 우선순위는 스크립트 안의 `NAMES`, `RISK` 사전에 있으므로 자기 환경에 맞게 고쳐 씁니다.

```bash
python scan_table.py scan-before.xml
```

```
주소            기기     포트  서비스       우선순위 점검할 것
192.168.88.10   프린터   631   ipp          3 낮음   인쇄 서비스. 접근 범위 확인
192.168.88.10   프린터   9100  jetdirect    3 낮음   프린터 직접 출력. 쓰지 않으면 끄기
192.168.88.20   NAS      21    ftp          1 높음   계정과 파일이 평문 전송. SMB나 SFTP로 대체
192.168.88.20   NAS      445   tcpwrapped   2 확인   파일 공유. 공유 대상과 계정 확인
192.168.88.30   공유기   23    telnet       1 높음   암호화 없는 원격 접속. 쓰지 않으면 끄기
192.168.88.30   공유기   80    http         2 확인   관리 화면. 기본 계정 변경, 내부 접속 제한 확인
192.168.88.40   일반 PC  -     (열린 포트 없음)

응답한 기기 4대, 열린 포트 6개
```

![기기 네 대 가운데 세 대에서 열린 포트 6개가 우선순위와 함께 정리되고 일반 PC는 열린 포트가 없는 것을 확인합니다.](https://copyandrun.com/img/home-office-network-nmap-open-services-check/03-open-ports-table.png)

## 4. 표 읽는 법과 끌 순서

<!-- files: scan_table.py -->

열려 있다는 것이 곧 취약하다는 뜻은 아닙니다. 프린터의 631번은 사무실 컴퓨터가 인쇄하는 데 쓰는 포트라서 열려 있는 것이 정상입니다. 판단 기준은 아래 목록의 앞 세 가지이며, 뒤의 세 항목은 포트별로 덧붙인 설명입니다.

- **지금 쓰는가**: 아무도 쓰지 않는 서비스는 끕니다. 프린터의 9100번 직접 출력이 그 예입니다.
- **암호화되는가**: telnet(23)과 FTP(21)는 계정과 내용이 평문으로 지나갑니다. 같은 일을 하는 SSH, SFTP, SMB로 바꿀 수 있으면 먼저 정리합니다.
- **누가 닿는가**: 관리 화면(80)은 기본 계정을 바꿨는지, 사무실 안에서만 열리는지 기기 설정에서 직접 확인합니다. 포트 점검만으로는 알 수 없습니다.
- **관리 화면 80번**: 기기가 HTTPS 관리 화면을 지원하면 그쪽으로 바꿉니다. 이 연습 환경의 흉내 서버는 HTTP만 있어 시험하지 않았습니다.
- **프린터 9100번**: 끄기 전에 사무실 컴퓨터가 이 포트로 인쇄하고 있지 않은지 먼저 확인합니다.
- **프린터 9100번과 탐지**: nmap 공식 문서(`https://nmap.org/book/vscan-fileformat.html`)에 따르면 기본 설정에서 TCP 9100~9107은 버전 탐지에서 제외됩니다. 프린터가 받은 데이터를 그대로 출력할 수 있기 때문이라는 것이 문서의 설명입니다. 이 글의 결과에서도 9100은 서비스 이름이 `jetdirect?`로만 나왔습니다.

그래서 이 글의 순서는 1순위 telnet과 FTP, 2순위 관리 화면과 파일 공유, 3순위 프린터 포트입니다. 이 순서는 제 연습용 기준이므로 사무실 사정에 맞게 `RISK`를 고칩니다.

## 5. 쓰지 않는 서비스를 끄고 다시 점검

<!-- files: lab_up.sh, scan.sh, scan_table.py -->

프린터의 9100, NAS의 FTP, 공유기의 telnet을 끄고(실제 기기에서는 각 기기의 관리 화면 설정) 같은 범위를 다시 점검합니다. 연습 환경에서는 `lab_up.sh after`가 세 기기를 해당 포트 없이 다시 띄웁니다. 그다음 조치 전후 결과를 비교합니다.

```bash
sh lab_up.sh after
sh scan.sh after
python scan_table.py scan-before.xml scan-after.xml
```

```
기기     조치 전          조치 후          닫힌 포트
프린터   631,9100         631              9100
NAS      21,445           445              21
공유기   23,80            80               23
일반 PC  -                -                -

열린 포트 6개 -> 3개
```

![조치 전 6개였던 열린 포트가 3개로 줄고 9100, 21, 23이 닫힌 것을 확인합니다.](https://copyandrun.com/img/home-office-network-nmap-open-services-check/05-after-rescan.png)

남은 포트 3개(631, 445, 80)는 용도가 있는 포트입니다. 이어서 할 일은 기기 설정에서 접근 범위와 기본 계정을 확인하는 것입니다.

## 정리

작업이 끝나면 아래 명령으로 컨테이너, 네트워크, 이미지를 지웁니다.

```bash
sh lab_down.sh
```

## 결과 정리

- 자기 소유 대역만, 범위를 좁혀서 점검합니다.
- 결과를 XML로 저장하고 파이썬으로 기기별 표를 만들면 조치 전후를 비교하기 쉽습니다.
- 열린 포트는 쓰는지, 암호화되는지, 누가 닿는지 세 가지로 판단하고 telnet과 평문 FTP부터 정리합니다.

## 자주 막히는 곳

- **`--open`을 붙였더니 일반 PC가 결과에서 사라집니다.** 처음에 `--open`을 넣고 스캔했을 때 응답한 기기가 4대인데도 결과 파일에는 3대만 있었습니다. 열린 포트가 없는 기기는 출력되지 않기 때문입니다. 이 글의 `scan.sh`는 `--open`을 쓰지 않습니다.
- **Git Bash에서 `docker cp`가 "Could not find the file /tmp/g.gnmap"으로 실패합니다.** `/tmp` 경로가 Windows 경로로 바뀌어서 난 오류입니다. 먼저 `export MSYS_NO_PATHCONV=1`을 실행합니다.
- **파이썬이 한글 출력에서 `UnicodeEncodeError`를 냅니다.** 출력을 받는 쪽이 cp1252일 때 난 오류이며 `PYTHONUTF8=1`을 주면 해결됩니다.
- **네트워크를 만들 때 주소 대역이 겹친다는 오류가 납니다.** 이 PC에서는 172.16~172.30 대역이 다른 네트워크에 쓰이고 있었습니다. 다른 사설 대역으로 바꿉니다.

## 확인 범위

- **확인한 것:** 위의 모든 명령과 출력은 Docker 컨테이너에서 실제로 실행한 결과입니다. nmap 옵션은 `https://nmap.org/book/man-briefoptions.html`, `https://nmap.org/book/man-output.html`(XML 권장, `-` 표준 출력, grepable deprecated), `https://nmap.org/book/man-port-scanning-techniques.html`(`-sT`는 관리자 권한 없이 가능)에서 확인했습니다.
- **하지 못한 것:** 실제 프린터, NAS, 공유기에서는 점검하지 않았습니다. 기기 컨테이너는 포트에 짧은 응답을 돌려주는 흉내라서 `-sV`의 서비스 이름과 버전 표시는 실제 기기와 다를 수 있습니다. 관리 화면의 기본 계정 여부는 확인하지 않았고, UDP 스캔과 전체 포트(65535개) 스캔도 하지 않았습니다. Linux와 macOS 명령은 실행하지 않았습니다.
- **범위의 한계:** 표의 우선순위는 이 글의 연습용 기준이며 위험도 판정이 아닙니다. 실제 사무실에서는 기기 제조사 문서와 사용 현황을 함께 보고 정합니다.

## 전체 코드

작업 폴더 구조는 아래와 같습니다.

```
Dockerfile
device.py
lab_up.sh
scan.sh
scan_table.py
lab_down.sh
```

### Dockerfile

```dockerfile
FROM python:3.12-alpine
COPY device.py /opt/device.py
ENTRYPOINT ["python", "-u", "/opt/device.py"]
```

### device.py

```python
"""사무실 기기를 흉내 내는 연습용 서버입니다. 지정한 포트에서 짧은 응답만 돌려줍니다.

사용법: python device.py 21:ftp 23:telnet 80:router 631:printer 445:tcp 9100:tcp
종류: ftp(FTP 인사말), telnet(로그인 프롬프트), router(관리 화면 HTML), printer(프린터 웹 화면), tcp(연결만 받음)
실제 서비스가 아니며 로그인 기능이 없습니다. 연습용 점검 대상으로만 씁니다.
"""
import socket
import sys
import threading

ROUTER_PAGE = """<html><head><title>Office Router Admin</title></head>
<body><h1>Office Router</h1><p>관리자 로그인 (연습용 화면, 입력은 처리하지 않습니다)</p>
<form><input name="user"><input name="pw" type="password"><button>Login</button></form></body></html>"""
PRINTER_PAGE = "<html><head><title>Office Printer</title></head><body><h1>Printer status: Ready</h1></body></html>"


def http_reply(server, body):
    data = body.encode("utf-8")
    head = f"HTTP/1.1 200 OK\r\nServer: {server}\r\nContent-Type: text/html; charset=utf-8\r\nContent-Length: {len(data)}\r\nConnection: close\r\n\r\n"
    return head.encode("ascii") + data


def handle(conn, kind):
    try:
        conn.settimeout(3)
        if kind == "ftp":
            conn.sendall(b"220 vsFTPd 3.0.5 ready\r\n")
            conn.recv(256)
            conn.sendall(b"530 Please login with USER and PASS.\r\n")
        elif kind == "telnet":
            conn.sendall(b"\xff\xfd\x18\xff\xfd\x20\r\nOffice Router\r\nlogin: ")
            conn.recv(256)
        elif kind == "router":
            conn.recv(1024)
            conn.sendall(http_reply("lab-httpd", ROUTER_PAGE))
        elif kind == "printer":
            conn.recv(1024)
            conn.sendall(http_reply("CUPS/2.4 IPP/2.1", PRINTER_PAGE))
        else:
            conn.recv(256)
    except OSError:
        pass
    finally:
        conn.close()


def serve(port, kind):
    s = socket.socket()
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    s.bind(("0.0.0.0", port))
    s.listen(16)
    while True:
        conn, _ = s.accept()
        threading.Thread(target=handle, args=(conn, kind), daemon=True).start()


def main():
    specs = [a.split(":") for a in sys.argv[1:]]
    for port, kind in specs:
        threading.Thread(target=serve, args=(int(port), kind), daemon=True).start()
    print("listening:", " ".join(sys.argv[1:]) or "(none)", flush=True)
    threading.Event().wait()


if __name__ == "__main__":
    main()
```

### lab_up.sh

```bash
#!/bin/sh
# 연습용 사무실 망을 만듭니다. 사용법: sh lab_up.sh before   (조치 후: sh lab_up.sh after)
MODE=${1:-before}
docker network inspect cr-p24-net >/dev/null 2>&1 || docker network create --subnet 192.168.88.0/24 cr-p24-net
docker image inspect cr-p24-device >/dev/null 2>&1 || docker build -q -t cr-p24-device .

# 기기 하나를 새로 띄웁니다: 이름, 주소, 포트 목록
dev() {
  name=$1; ip=$2; shift 2
  docker rm -f "$name" >/dev/null 2>&1
  case "$name" in
    cr-p24-router) pub="-p 127.0.0.1:18190:80" ;;
    *) pub="" ;;
  esac
  docker run -d --name "$name" --network cr-p24-net --ip "$ip" $pub cr-p24-device "$@" >/dev/null
}

if [ "$MODE" = "before" ]; then
  dev cr-p24-printer 192.168.88.10 631:printer 9100:tcp
  dev cr-p24-nas     192.168.88.20 21:ftp 445:tcp
  dev cr-p24-router  192.168.88.30 80:router 23:telnet
else
  # 조치 후: 프린터 9100, NAS FTP, 라우터 telnet 을 끕니다.
  dev cr-p24-printer 192.168.88.10 631:printer
  dev cr-p24-nas     192.168.88.20 445:tcp
  dev cr-p24-router  192.168.88.30 80:router
fi

# 일반 PC: 열린 서비스가 없는 기기
docker inspect cr-p24-pc >/dev/null 2>&1 || docker run -d --name cr-p24-pc --network cr-p24-net --ip 192.168.88.40 --entrypoint sleep cr-p24-device 3600 >/dev/null
docker ps --filter name=cr-p24- --format 'table {{.Names}}\t{{.Ports}}'
```

### scan.sh

```bash
#!/bin/sh
# 자기 소유 연습 대역(192.168.88.10-40)만 점검합니다. 사용법: sh scan.sh before   (결과: scan-before.xml, scan-before.gnmap)
LABEL=${1:-before}
TARGET=192.168.88.10-40
docker rm -f cr-p24-scan >/dev/null 2>&1
docker run --name cr-p24-scan --network cr-p24-net --ip 192.168.88.50 instrumentisto/nmap \
  -sT -sV -n -oX - -oG /tmp/g.gnmap $TARGET > "scan-$LABEL.xml"
docker cp cr-p24-scan:/tmp/g.gnmap "scan-$LABEL.gnmap"
docker rm -f cr-p24-scan >/dev/null
echo "저장: scan-$LABEL.xml, scan-$LABEL.gnmap"
```

### scan_table.py

```python
"""nmap XML 결과로 기기별 열린 포트 표를 만듭니다.

사용법: python scan_table.py scan-before.xml            (한 번의 결과 표)
        python scan_table.py scan-before.xml scan-after.xml   (조치 전후 비교)
"""
import sys
import unicodedata
import xml.etree.ElementTree as ET

# 주소 -> 기기 이름 (연습 환경에서 정한 값)
NAMES = {
    "192.168.88.10": "프린터",
    "192.168.88.20": "NAS",
    "192.168.88.30": "공유기",
    "192.168.88.40": "일반 PC",
}
# 포트 -> (우선순위, 점검할 것). 열려 있다는 사실만으로 취약하다고 판단하지 않습니다.
RISK = {
    23: ("1 높음", "암호화 없는 원격 접속. 쓰지 않으면 끄기"),
    21: ("1 높음", "계정과 파일이 평문 전송. SMB나 SFTP로 대체"),
    80: ("2 확인", "관리 화면. 기본 계정 변경, 내부 접속 제한 확인"),
    445: ("2 확인", "파일 공유. 공유 대상과 계정 확인"),
    9100: ("3 낮음", "프린터 직접 출력. 쓰지 않으면 끄기"),
    631: ("3 낮음", "인쇄 서비스. 접근 범위 확인"),
}


def pad(text, width):
    """한글은 두 칸으로 세어 열을 맞춥니다."""
    used = sum(2 if unicodedata.east_asian_width(c) in "WF" else 1 for c in str(text))
    return str(text) + " " * max(1, width - used)


def load(path):
    """주소 -> [(포트, 서비스, 제품)] 과 응답한 주소 목록."""
    root = ET.parse(path).getroot()
    result, up = {}, []
    for host in root.findall("host"):
        addr = host.find("address").get("addr")
        up.append(addr)
        ports = []
        for p in host.findall("./ports/port"):
            if p.find("state").get("state") != "open":
                continue
            svc = p.find("service")
            name = svc.get("name", "?") if svc is not None else "?"
            prod = " ".join(x for x in (svc.get("product"), svc.get("version")) if x) if svc is not None else ""
            ports.append((int(p.get("portid")), name, prod))
        result[addr] = sorted(ports)
    return result, up


def table(path):
    data, up = load(path)
    print(pad("주소", 16) + pad("기기", 9) + pad("포트", 6) + pad("서비스", 13) + pad("우선순위", 9) + "점검할 것")
    for addr in up:
        label = NAMES.get(addr, "미확인")
        if not data[addr]:
            print(pad(addr, 16) + pad(label, 9) + pad("-", 6) + "(열린 포트 없음)")
        for port, name, prod in data[addr]:
            rank, note = RISK.get(port, ("2 확인", "용도 확인"))
            print(pad(addr, 16) + pad(label, 9) + pad(port, 6) + pad(name, 13) + pad(rank, 9) + note)
    total = sum(len(v) for v in data.values())
    print(f"\n응답한 기기 {len(up)}대, 열린 포트 {total}개")


def compare(before, after):
    b, _ = load(before)
    a, _ = load(after)
    print(pad("기기", 9) + pad("조치 전", 17) + pad("조치 후", 17) + "닫힌 포트")
    nb = na = 0
    for addr in sorted(b):
        pb = {p for p, _, _ in b[addr]}
        pa = {p for p, _, _ in a.get(addr, [])}
        nb, na = nb + len(pb), na + len(pa)
        fmt = lambda s: ",".join(map(str, sorted(s))) or "-"
        print(pad(NAMES.get(addr, addr), 9) + pad(fmt(pb), 17) + pad(fmt(pa), 17) + fmt(pb - pa))
    print(f"\n열린 포트 {nb}개 -> {na}개")


if __name__ == "__main__":
    sys.stdout.reconfigure(encoding="utf-8")
    if len(sys.argv) == 2:
        table(sys.argv[1])
    elif len(sys.argv) == 3:
        compare(sys.argv[1], sys.argv[2])
    else:
        sys.exit(__doc__)
```

### lab_down.sh

```bash
#!/bin/sh
# 연습용 컨테이너, 이미지, 네트워크를 지웁니다.
docker rm -f cr-p24-printer cr-p24-nas cr-p24-router cr-p24-pc cr-p24-scan >/dev/null 2>&1
docker network rm cr-p24-net
docker rmi cr-p24-device
```
