Bubblewrap (bwrap) — 루트리스 샌드박스

Bubblewrap 은 루트 권한 없이 네임스페이스 격리를 제공하는 샌드박스 도구입니다. Flatpak, xdg-desktop-portal, systemd-sandboxed 서비스의 기반 기술로 활용됩니다.

개요

Bubblewrap(bwrap) 은 루트 권한 없이 동작하는 샌드박스 도구입니다. 2016 년 Project Atomic 에서 시작되었으며, 현재는 GitHub - containers/bubblewrap에서 유지보수됩니다.

Docker/runc 가 "풀 컨테이너"를 목표로 하는 반면, bwrap 은 단일 애플리케이션 격리에 최적화되어 있습니다. 이로 인해 다음과 같은 특징을 가집니다:

• 단일 바이너리 — 의존성 없이 정적 컴파일된 100KB 크기 실행 파일
• 루트리스 — user namespace 를 활용해 일반 사용자로 실행 가능
• 최소 권한 — 필요한 mount/bind 만 구성, 나머지는 차단
• Flatpak 기반 — Flatpak 런타임의 샌드박스 백엔드로 사용됨
• xdg-desktop-portal 통합 — 데스크톱 애플리케이션의 파일/네트워크 접근 제어

Docker/runc 와의 비교

Bubblewrap 은 Docker/runc 와 다음과 같은 차이가 있습니다:

아키텍처

네임스페이스 계층 구조

Bubblewrap 은 다음과 같은 순서로 네임스페이스를 생성합니다:

마운트 흐름 다이어그램

Bubblewrap 이 파일시스템 뷰를 재구성하는 과정을 시각화했습니다:

Bubblewrap 생명주기 흐름

Bubblewrap 이 시작되고 종료될 때까지의 전체 흐름을 시각화했습니다:

네임스페이스 생성 순서는 다음과 같습니다:

1. User Namespace 먼저 생성 — 루트 권한 없이 다른 네임스페이스를 생성하기 위한 선행 조건
2. PID/Mount/Network 네임스페이스 — user namespace 내에서 추가 생성
3. UID/GID 매핑 — /proc/[pid]/uid_map, /proc/[pid]/gid_map 기록
4. Mount 설정 — bind mount, tmpfs, proc/sysfs 재마운트
5. Seccomp/Capability 적용 — 최종 권한 제한

마운트 전략

Bubblewrap 의 핵심은 mount namespace 를 활용한 파일시스템 격리입니다. 주요 마운트 옵션은 다음과 같습니다:

커널 내부 구현

User Namespace 생성 흐름

Bubblewrap 이 user namespace 를 생성하는 과정은 다음과 같습니다:

/* bubblewrap 소스: newinstance() 함수 간략화 */
static void
newinstance(struct launch_options *launch_opts)
{
    uid_t uid = getuid();
    gid_t gid = getgid();

    /* 1. User Namespace 생성 */
    if (unshare(CLONE_NEWUSER) == -1)
        die("Failed to unshare user namespace: %s", strerror(errno));

    /* 2. UID 매핑 설정 */
    write_uid_gid_map(uid, gid);

    /* 3. 다른 네임스페이스 생성 (이제 루트 권한 없이 가능) */
    if (launch_opts->share_pid_ns == 0) {
        if (unshare(CLONE_NEWPID) == -1)
            die("Failed to unshare PID namespace: %s", strerror(errno));
    }

    if (launch_opts->share_net_ns == 0) {
        if (unshare(CLONE_NEWNET) == -1)
            die("Failed to unshare network namespace: %s", strerror(errno));
    }

    /* 4. Mount Namespace 는 항상 생성 */
    if (unshare(CLONE_NEWNS) == -1)
        die("Failed to unshare mount namespace: %s", strerror(errno));
}

UID/GID 매핑 상세

User namespace 의 UID 매핑은 /proc/[pid]/uid_map 파일에 기록됩니다. 형식은 다음과 같습니다:

# 형식: <내부 UID> <외부 UID> <길이>
0 1000 1      # 내부 uid 0 → 외부 uid 1000 (1 개 매핑)
1 100000 65536  # 내부 uid 1-65536 → 외부 uid 100000-165535

Bubblewrap 은 기본적으로 단일 사용자 매핑만 사용합니다 (내부 uid 0 = 외부 일반 사용자). Flatpak 은 /etc/subuid, /etc/subgid 를 활용해 더 넓은 범위를 매핑합니다.

# /etc/subuid 예시
minzkn:100000:65536

# bwrap 에서 subuid 활용 (Flatpak 스타일)
$ bwrap --uid 0 --gid 0 \
    --ro-bind /usr /usr \
    --bind /home/minzkn/app /app \
    -- /usr/bin/flatpak-app

Seccomp-BPF 필터

Bubblewrap 은 Seccomp-BPF를 활용해 위험한 시스템콜을 차단합니다. 기본 필터는 다음과 같습니다:

/* bubblewrap 소스: seccomp.c 간략화 */
static const struct scmp_syscall blocked_syscalls[] = {
    "ptrace",
    "process_vm_readv",
    "process_vm_writev",
    "init_module",
    "finit_module",
    "delete_module",
    "kexec_load",
    "kexec_file_load",
    "userfaultfd",
    "bpf",
    { 0 }
};

static void
setup_seccomp(void)
{
    struct scmp_arg_cmp arg_cmp;
    int i;

    for (i = 0; blocked_syscalls[i].name != NULL; i++) {
        int syscall = scmp_syscall_resolve_name(blocked_syscalls[i].name);
        if (syscall < 0)
            continue;

        scmp_rule_add(ctx, SCMP_ACT_ERRNO(EPERM), syscall);
    }

    scmp_load_program(ctx);
}

마운트 설정 상세 구현

Bubblewrap 이 bind mount 와 tmpfs 를 설정하는 내부 코드입니다:

/* bubblewrap 소스: bind_mount() 및 do_mount() 간략화 */
static void
bind_mount(const char *src, const char *dest, int read_only)
{
    /* 1. 먼저 bind mount 수행 */
    if (mount(src, dest, "bind", MS_BIND | MS_REC, NULL) == -1)
        die("Failed to bind mount %s -> %s: %s", src, dest, strerror(errno));

    /* 2. 읽기 전용 옵션이 있으면 remount */
    if (read_only) {
        unsigned long flags = MS_BIND | MS_REMOUNT | MS_RDONLY | MS_REC;
        if (mount(src, dest, "bind", flags, NULL) == -1)
            die("Failed to remount read-only %s: %s", dest, strerror(errno));
    }
}

static void
mount_tmpfs(const char *dest)
{
    /* tmpfs 마운트: 메모리 기반 파일시스템 */
    if (mount("tmpfs", dest, "tmpfs", MS_NOSUID | MS_NODEV, "mode=755") == -1)
        die("Failed to mount tmpfs on %s: %s", dest, strerror(errno));
}

Capability 드롭

Bubblewrap 은 exec 직전 모든 capability 를 드롭합니다. 이는 샌드박스 내부에서 setuid 바이너리 등을 통한 권한 상승을 방지합니다.

/* bubblewrap 소스: drop_capabilities() 간략화 */
static void
drop_capabilities(void)
{
    struct __user_cap_header_struct hdr;
    struct __user_cap_data_struct data[2];

    hdr.version = _LINUX_CAPABILITY_VERSION_3;
    hdr.pid = 0;

    /* 모든 capability 를 0 으로 클리어 */
    data[0].effective = 0;
    data[0].permitted = 0;
    data[0].inheritable = 0;
    data[1].effective = 0;
    data[1].permitted = 0;
    data[1].inheritable = 0;

    if (capset(&hdr, data) == -1)
        die("Failed to capset: %s", strerror(errno));
}

사용법

기본 샌드박스

가장 간단한 bwrap 사용법입니다:

# 최소 샌드박스: / 만 읽기 전용으로 마운트
$ bwrap --ro-bind / / --dev /dev --proc /proc --unshare-all --share-net \
    --chdir /home/minzkn -- uid 0 sh

# 샌드박스 내부 확인
bwrap$ id
uid=0(root) gid=0(root) groups=0(root)

bwrap$ mount | head -5
overlay on / type overlay (...)
proc on /proc type proc (...)
dev on /dev type devtmpfs (...)

bwrap$ cat /proc/1/status | grep -E "^(Name|Pid|PPid)"
Name:   uid
Pid:    1
PPid:   1

--unshare-all 옵션은 모든 네임스페이스를 격리하며, --share-net은 네트워크 네임스페이스만 공유합니다 (인터넷 접근 필요 시).

Flatpak 스타일 격리

Flatpak 이 bwrap 을 사용하는 방식을 모방한 예시입니다:

# Flatpak 스타일: 최소 파일시스템 + 사용자 디렉터리 일부 마운트
$ bwrap \
    --ro-bind /usr /usr \
    --ro-bind /lib /lib \
    --ro-bind /lib64 /lib64 \
    --bind /home/minzkn/.var/app/com.example.MyApp /app/data \
    --bind /home/minzkn/Music /app/data/Music:ro \
    --tmpfs /tmp \
    --proc /proc \
    --dev /dev \
    --unset-env SECRET \
    --setenv APP_HOME /app \
    --setenv XDG_RUNTIME_DIR /run/user/1000 \
    --bind /run/user/1000 /run/user/1000 \
    --sync-fd 3 \
    -- /usr/bin/flatpak-app

네트워크 격리

네트워크 네임스페이스를 격리하면 외부 접근이 완전히 차단됩니다:

# 네트워크 완전 차단
$ bwrap --ro-bind / / --dev /dev --proc /proc --unshare-net \
    -- ping 8.8.8.8
ping: socket: Operation not permitted

# 네트워크 공유 (기본값: --share-net)
$ bwrap --ro-bind / / --dev /dev --proc /proc \
    -- curl -s https://example.com | head

장치 접근 제어

특정 장치만 접근 가능하게 구성할 수 있습니다:

# 필수 장치만 마운트
$ bwrap --ro-bind / / \
    --dev /dev/null \
    --dev /dev/zero \
    --dev /dev/random \
    --dev /dev/urandom \
    --dev /dev/tty \
    --proc /proc \
    -- /bin/sh

# GPU 접근 허용 (드结实게 필요)
$ bwrap --ro-bind / / \
    --dev /dev/dri/card0 \
    --dev /dev/dri/renderD128 \
    -- /usr/bin/gpu-app

실전 활용 예시

1. 웹 브라우저 샌드박스

# Firefox 을 bwrap 으로 샌드박스 실행
$ bwrap \
    --ro-bind /usr /usr \
    --ro-bind /lib /lib \
    --ro-bind /lib64 /lib64 \
    --bind /home/minzkn/Downloads /app/Downloads \
    --bind /home/minzkn/Documents /app/Documents:ro \
    --tmpfs /tmp \
    --tmpfs /var/tmp \
    --proc /proc \
    --dev /dev \
    --dev /dev/dri/card0 \
    --dev /dev/dri/renderD128 \
    --bind /run/user/1000/pulse /run/user/1000/pulse \
    --bind /run/user/1000/bus /run/user/1000/bus \
    --setenv PULSE_SERVER unix:/run/user/1000/pulse/native \
    --setenv DBUS_SESSION_BUS_ADDRESS unix:path=/run/user/1000/bus \
    --unshare-pid \
    --new-session \
    -- /usr/bin/firefox --no-remote

2. 신뢰할 수 없는 스크립트 실행

# 다운로드받은 불신 스크립트 실행 (네트워크 차단, 홈 디렉터리 보호)
$ bwrap \
    --ro-bind /usr /usr \
    --ro-bind /bin /bin \
    --ro-bind /lib /lib \
    --tmpfs /home \
    --tmpfs /var \
    --tmpfs /tmp \
    --proc /proc \
    --dev /dev \
    --unshare-net \
    --unset-env HOME \
    --setenv HOME /home \
    -- /bin/bash /path/to/untrusted-script.sh

3. CI/CD 빌드 환경 격리

# CI 파이프라인에서 빌드 작업 격리 (호스트 오염 방지)
$ bwrap \
    --ro-bind /usr /usr \
    --ro-bind /etc /etc \
    --bind /workspace/build /app \
    --bind /workspace/output /output \
    --tmpfs /tmp \
    --proc /proc \
    --dev /dev \
    --unshare-net \
    --cap-drop-all \
    -- /usr/bin/make -j$(nproc) dist

4. 멀티미디어 인코딩 샌드박스

# ffmpeg 인코딩 (GPU 가속 + 입력/출력 디렉터리만 접근)
$ bwrap \
    --ro-bind /usr /usr \
    --ro-bind /lib /lib \
    --ro-bind /lib64 /lib64 \
    --bind /media/videos/input /input:ro \
    --bind /media/videos/output /output \
    --dev /dev/dri/card0 \
    --dev /dev/dri/renderD128 \
    --tmpfs /tmp \
    --proc /proc \
    --dev /dev \
    --unshare-net \
    -- /usr/bin/ffmpeg -i /input/source.mp4 -c:v h264_vaapi /output/encoded.mp4

5. 개발 환경 격리 (프로젝트별)

# 프로젝트별 독립적인 개발 환경 (전역 패키지 오염 방지)
$ bwrap \
    --ro-bind /usr /usr \
    --ro-bind /lib /lib \
    --bind /projects/myapp /app \
    --bind /projects/myapp/venv /venv \
    --tmpfs /home \
    --tmpfs /tmp \
    --proc /proc \
    --dev /dev \
    --share-net \
    --setenv VIRTUAL_ENV /venv \
    --setenv PATH /venv/bin:/usr/bin \
    --setenv HOME /home \
    -- /venv/bin/python /app/main.py

전체 명령 옵션 레퍼런스

Bubblewrap 의 모든 명령행 옵션을 카테고리별로 정리했습니다:

네임스페이스 옵션

파일시스템 옵션

환경 변수 옵션

보안 옵션

고급/디버깅 옵션

보안 심층 분석

User Namespace 보안 함의

User namespace 는 강력한 격리 수단이지만, 몇 가지 보안 고려사항이 있습니다:

• 내부 루트 ≠ 외부 루트 — 샌드박스 내부 uid 0 은 외부 일반 사용자에 매핑됩니다. 따라서 chown root도 외부에서는 일반 사용자 소유로 인식됩니다.
• Capability 는 namespace 내에서만 유효 — 내부에서 CAP_SYS_ADMIN 을 가져도 외부 파일시스템에는 적용되지 않습니다.
• Setuid 바이너리 무효화 — user namespace 내부에서 setuid 바이너리는 효과적으로 동작하지 않습니다 (커널 설정에 따라 다름).

# 샌드박스 내부에서 root 소유 파일 생성
bwrap$ touch /app/data/rootfile
bwrap$ chown root:root /app/data/rootfile
bwrap$ ls -l /app/data/rootfile
-rw-r--r-- 1 root root 0 May 10 10:00 /app/data/rootfile

# 외부에서 확인 (실제 소유자는 일반 사용자)
$ ls -l /home/minzkn/.var/app/com.example.MyApp/rootfile
-rw-r--r-- 1 minzkn minzkn 0 May 10 10:00 /home/minzkn/.var/app/.../rootfile

--share-net 보안 위험

--share-net 옵션은 네트워크 네임스페이스를 호스트와 공유합니다. 이는 다음과 같은 위험을 내포합니다:

• 로컬 네트워크 접근 — 샌드박스 내부에서 호스트가 리스닝하는 소켓에 접근 가능
• Raw 소켓 생성 — CAP_NET_RAW 가 드롭되었더라도 일부 소켓 연산 가능
• 네트워크 스니핑 — AF_PACKET 소켓을 통한 패킷 캡처 시도 (차단 필요)

커널 설정 의존성

Bubblewrap 동작에 필요한 커널 설정 옵션입니다:

# 현재 커널 설정 확인
$ zgrep USER_NS /proc/config.gz
CONFIG_USER_NS=y

# 또는
$ grep USER_NS /boot/config-$(uname -r)
CONFIG_USER_NS=y

CVE 취약점 및 공격 시나리오

Bubblewrap 과 user namespace 관련 주요 CVE 사례입니다:

CVE-2026-41163 — setuid 모드 ptrace 취약점 (최신)

2026 년 4 월 발견된 이 취약점은 setuid 모드에서 bubblewrap 이 dumpable 플래그를 설정하지 않아 발생했습니다. 공격자는 ptrace 를 통해 저권한 설정 프로세스를 디버깅하고 메모리를 조작할 수 있습니다.

CVE-2022-0185 — Linux Kernel Use-After-Free in fs_context

2022 년 2 월 발견된 이 취약점은 user namespace 내부에서 mount 작업 수행 시 use-after-free 를 유발할 수 있습니다. 공격자는 로컬 루트 권한 상승이 가능합니다.

# CVE-2022-0185 개념 증명 (간략화, 실제 공격 코드 아님)
$ unshare -Urmn bash
# 내부에서 fs_context 조작으로 UAF 트리거
# → heap corruption → privilege escalation

CVE-2021-4154 — use-after-free in getname_flags

이 취약점은 unshare()와 execve() 사이의 경쟁 조건을 악용합니다:

// CVE-2021-4154 공격 흐름 (의사 코드)
pid_t pid = fork();
if (pid == 0) {
    unshare(CLONE_FS);          /* 파일시스템 정보 공유 해제 */
    execve(exploreit);          /* 경쟁 조건 트리거 */
}
/* 부모 프로세스는 동시에 fs 구조 변조 */

Bubblewrap 빌드 옵션 및 보안 설정

v0.11.2 에서 도입된 새로운 빌드 옵션입니다:

# setuid 지원 비활성화 (권장 - 기본값)
$ meson setup _builddir -Dsupport_setuid=false
$ meson compile -C _builddir

# setuid 지원 활성화 (레거시 시스템용)
$ meson setup _builddir -Dsupport_setuid=true
$ meson compile -C _builddir

Ubuntu 25.04 의 AppArmor 프로파일

Ubuntu 25.04 에서는 bubblewrap 을 위한 AppArmor 프로파일이 기본 제공됩니다:

# AppArmor 프로파일 확인
$ aa-status | grep bwrap
  /usr/bin/bwrap
  bwrap-userns-restrict

# 프로파일 내용 요약
$ sudo cat /etc/apparmor.d/usr.bin.bwrap
# bwrap-userns-restrict: user namespace 생성 허용
# → 샌드박스 설정 완료 후 더 엄격한 프로파일로 전환

이 프로파일은 bubblewrap 이 user namespace 를 생성하고 샌드박스를 설정할 수 있도록 허용한 후, 실행 중인 애플리케이션에 대해 더 제한적인 정책을 적용합니다.

Bubblewrap 우회 공격 시나리오

다음과 같은 설정 오류 시 샌드박스 탈출이 가능합니다:

# 시나리오 1: --bind로 호스트 /root 바인드 (치명적 실수)
$ bwrap --ro-bind / / --bind /root /root -- /bin/bash
# 샌드박스 내부에서 /root/.ssh/id_rsa 접근 가능

# 시나리오 2: --dev로 위험한 장치 노출
$ bwrap --ro-bind / / --dev /dev/mem -- /bin/bash
# /dev/mem 직접 접근으로 물리 메모리 읽기/쓰기 가능

# 시나리오 3: procfs 통한 호스트 프로세스 조작
$ bwrap --ro-bind / / --proc /proc -- /bin/bash
# /proc/[host-pid]/mem 접근 시도 (ptrace_scope 설정에 따라 다름)

디버깅

strace 시스템콜 추적

bwrap 이 수행하는 시스템콜을 추적하면 내부 동작을 파악할 수 있습니다:

# bwrap 시스템콜 추적
$ strace -f bwrap --ro-bind / / --dev /dev --proc /proc -- uid 0 sh 2>&1 | \
    grep -E "^(unshare|mount|capset|prctl)" | head -20

unshare(CLONE_NEWUSER)                      = 0
mount("proc", "/proc", "proc", MS_NOSUID|MS_NODEV|MS_NOEXEC, NULL) = 0
capset({version=_LINUX_CAPABILITY_VERSION_3, pid=0}, []) = 0
prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)   = 0
execve("/bin/sh", [["/bin/sh"]], [...])    = 0

네임스페이스 확인

실행 중인 bwrap 프로세스의 네임스페이스를 확인할 수 있습니다:

# bwrap 프로세스 찾기
$ pgrep -f "bwrap.*uid 0"
12345

# 네임스페이스 확인
$ ls -l /proc/12345/ns/
total 0
lrwxrwxrwx 1 minzkn minzkn 0 May 10 10:00 cgroup -> 'cgroup:[4026531835]'
lrwxrwxrwx 1 minzkn minzkn 0 May 10 10:00 ipc -> 'ipc:[4026532280]'
lrwxrwxrwx 1 minzkn minzkn 0 May 10 10:00 mnt -> 'mnt:[4026532278]'
lrwxrwxrwx 1 minzkn minzkn 0 May 10 10:00 net -> 'net:[4026531992]'
lrwxrwxrwx 1 minzkn minzkn 0 May 10 10:00 pid -> 'pid:[4026532279]'
lrwxrwxrwx 1 minzkn minzkn 0 May 10 10:00 pid_for_children -> 'pid:[4026532279]'
lrwxrwxrwx 1 minzkn minzkn 0 May 10 10:00 user -> 'user:[4026532277]'
lrwxrwxrwx 1 minzkn minzkn 0 May 10 10:00 uts -> 'uts:[4026532281]'

# 호스트 네임스페이스와 비교
$ ls -l /proc/self/ns/ | grep -E "^(mnt|pid|user)"
lrwxrwxrwx 1 minzkn minzkn 0 May 10 10:00 mnt -> 'mnt:[4026531840]'
lrwxrwxrwx 1 minzkn minzkn 0 May 10 10:00 pid -> 'pid:[4026531836]'
lrwxrwxrwx 1 minzkn minzkn 0 May 10 10:00 user -> 'user:[4026531837]'

네임스페이스 ID 가 다르면 격리되었음을 의미합니다.

Capability 검증

샌드박스 내부의 capability 를 확인할 수 있습니다:

# 샌드박스 내부에서 capability 확인
$ bwrap --ro-bind / / --dev /dev --proc /proc -- capsh --print
Current: cap_chown,cap_setuid,cap_setgid+ep
Bounding set =0

# 모든 capability 드롭 후
$ bwrap --ro-bind / / --dev /dev --proc /proc --cap-drop-all -- capsh --print
Current: =
Bounding set =0

고급 디버깅 기법

1. 네임스페이스 진입 (nsenter)

실행 중인 bwrap 샌드박스에 외부에서 진입할 수 있습니다:

# bwrap 프로세스 PID 찾기
$ pgrep -f "bwrap.*uid 0"
12345

# 해당 네임스페이스로 진입
$ sudo nsenter -t 12345 -a -- /bin/bash
# -a: 모든 네임스페이스 진입
# -t TARGET_PID: 대상 프로세스

# 샌드박스 내부 확인
(nsenter)# pwd
/
(nsenter)# mount | grep tmpfs
tmpfs on /tmp type tmpfs (...)

2. Mount Namespace 상세 분석

# 마운트 이벤트 추적 (mountinfo)
$ cat /proc/12345/mountinfo | head -20
128 52 0:82 / / rw,nosuid,nodev,relatime - tmpfs tmpfs rw,size=1024k
129 128 0:5 / /proc rw,nosuid,nodev,noexec,relatime - proc proc rw
130 128 0:83 /dev /dev rw,nosuid - devtmpfs devtmpfs rw,size=3896988k

# 마운트 옵션 상세
$ sudo cat /proc/12345/mountstats | grep -A5 "^device tmpfs"
device tmpfs mounted on /tmp with fstype tmpfs
 - stats: major 0 minor 82
 - write: 123 456789
 - read: 456 123456

3. Seccomp 필터 분석

# 적용된 seccomp 필터 확인
$ grep Seccomp /proc/12345/status
Seccomp:	2
Seccomp_filters:	1

# 차단된 시스템콜 로그 (dmesg)
$ dmesg | grep -i "seccomp" | tail -10
[12345.678901] audit: type=1326 audit(...): pid=12345 comm="bwrap" syscall=bpf ... seccomp
[12345.678902] audit: type=1326 audit(...): pid=12345 comm="bwrap" syscall=ptrace ... seccomp

4. Performance Profiling (perf)

# bwrap 시작 시간 프로파일링
$ perf record -g -p 12345 sleep 1
$ perf report --stdio | head -50

# 마운트 오버헤드 분석
$ perf trace -p 12345 -e mount,umount2 --duration 100us
  15.234 mount(0x7fff12345000, 0x7fff12346000, "bind", ...) = 0 <2.345 ms>
  18.567 mount(0x7fff12347000, 0x7fff12348000, "tmpfs", ...) = 0 <1.234 ms>

5. AppArmor/SELinux 감사 로그

# AppArmor 감사 로그
$ sudo grep "bwrap" /var/log/kern.log | tail -20
kernel: [12345.678] audit: type=1400 audit(...): apparmor="DENIED" operation="open" profile="bwrap" name="/etc/shadow" ...

# SELinux 감사 로그
$ sudo ausearch -m avc -ts recent | grep bwrap
type=AVC msg=audit(...): avc: denied { read } for pid=12345 comm="bwrap" name="shadow" ...

실전 통합 사례

Flatpak 통합

Flatpak 은 bwrap 을 샌드박스 백엔드로 사용합니다. Flatpak 런타임은 다음과 같이 bwrap 을 호출합니다:

# Flatpak 이 내부적으로 수행하는 bwrap 호출 (간략화)
bwrap \
    --args /tmp/flatpak-bwrap-args.XXXXXX \
    --unshare-try \
    --share-network \
    --share-ipc \
    --setenv FLATPAK_ID com.example.MyApp \
    --setenv FLATPAK_ARCH x86_64 \
    -- /usr/bin/flatpak-bwrap-entrypoint

Flatpak 은 --filesystem=home, --socket=X11, --device=dri 등 고급 권한 옵션을 bwrap 명령어로 변환합니다.

XDG Desktop Portal

xdg-desktop-portal은 데스크톱 애플리케이션이 샌드박스 밖의 리소스 (파일, 알림, 카메라) 에 안전하게 접근하도록 하는 중계자입니다. bwrap 과 연동하여 다음과 같은 기능을 제공합니다:

• FilePortal — 파일 선택 다이얼로그를 통한 파일 접근 (직접 경로 지정 금지)
• NotificationPortal — 데스크톱 알림 전송
• CameraPortal — 웹캠 접근 제어
• SecretPortal — 키링 (Secret Service) 접근

systemd-sandboxed 서비스

systemd 는 SystemCallFilter=, CapabilityBoundingSet=, PrivateTmp= 등 유닛 설정을 통해 샌드박싱을 제공합니다. 내부적으로 bwrap 과 유사한 네임스페이스 격리를 사용합니다.

[Unit]
Description=My Sandboxed Service

[Service]
Type=simple
ExecStart=/usr/bin/myapp
User=myappuser

# 샌드박스 옵션
PrivateTmp=yes
ProtectSystem=strict
ProtectHome=yes
ReadWritePaths=/var/lib/myapp
CapabilityBoundingSet=CAP_NET_BIND_SERVICE
SystemCallFilter=@system-service
SystemCallErrorNumber=EPERM
NoNewPrivileges=yes

한계 및 주의사항

알려진 한계

• User Namespace 의존 — 일부 배포판 (Ubuntu 등) 은 보안 이유로 user namespace 를 제한합니다. /proc/sys/kernel/unprivileged_userns_clone=0 확인 필요.
• SELinux/AppArmor 충돌 — bwrap 이 SELinux/AppArmor 정책을 우회하지는 않습니다. 추가 정책 설정이 필요할 수 있습니다.
• 성능 오버헤드 — bind mount 가 많을수록 마운트 네임스페이스 설정 시간이 증가합니다 (수십 ms 수준).
• 하드웨어 접근 제한 — GPU, USB 등 특수 장치는 추가 설정 없이 접근 불가.

보안 고려사항

문제 해결 (Troubleshooting)

자주 발생하는 오류

1. "unshare: Operation not permitted"

$ bwrap --unshare-pid -- /bin/bash
unshare: Operation not permitted

원인: 커널이 unprivileged user namespace 를 비활성화했습니다.

# 확인
$ cat /proc/sys/kernel/unprivileged_userns_clone
0  # 0 이면 비활성화

# 임시 활성화 (재부팅 시 초기화)
$ sudo sysctl -w kernel.unprivileged_userns_clone=1

# 영구 활성화
$ echo "kernel.unprivileged_userns_clone = 1" | sudo tee /etc/sysctl.d/99-userns.conf

$ sudo aa-complain /usr/bin/bwrap

2. "Failed to mount: Permission denied"

$ bwrap --ro-bind /data /data -- /bin/bash
Failed to mount /data: Permission denied

원인: SELinux/AppArmor 가 마운트를 차단하거나, 소스 디렉터리 접근 권한이 없습니다.

# SELinux 감사 로그 확인
$ sudo ausearch -m avc -ts recent | grep bwrap

# AppArmor 로그 확인
$ sudo grep bwrap /var/log/kern.log

# 소스 디렉터리 권한 확인
$ ls -ld /data
drwx------ 2 root root 4096 May 10 10:00 /data

# 해결: 권한 완화 또는 SELinux 컨텍스트 설정
$ chmod o+rx /data
$ chcon -R -t public_content_t /data  # SELinux

3. "bwrap: exec failed: No such file or directory"

$ bwrap --ro-bind / / -- /usr/bin/myapp
bwrap: exec failed: No such file or directory

원인: 샌드박스 내부에서 실행 파일이나 공유 라이브러리를 찾을 수 없습니다.

# 동적 링커 확인
$ readelf -l /usr/bin/myapp | grep interpreter
      [Requesting program interpreter: /lib64/ld-linux-x86-64.so.2]

# 필요한 라이브러리 확인
$ ldd /usr/bin/myapp
        linux-vdso.so.1
        libc.so.6 => /lib64/libc.so.6
        /lib64/ld-linux-x86-64.so.2

# 해결: 필요한 라이브러리 모두 바인드
$ bwrap \
    --ro-bind /usr /usr \
    --ro-bind /lib /lib \
    --ro-bind /lib64 /lib64 \
    -- /usr/bin/myapp

4. "No space left on device" (tmpfs)

$ bwrap --tmpfs /tmp -- /bin/bash
$ dd if=/dev/zero of=/tmp/test bs=1M count=100
dd: error writing '/tmp/test': No space left on device

원인: tmpfs 는 기본값으로 메모리의 50% 를 사용합니다. 대용량 작업 시 부족할 수 있습니다.

# 현재 tmpfs 크기 확인
$ df -h /tmp
Filesystem      Size  Used Avail Use% Mounted on
tmpfs           3.9G     0  3.9G   0% /tmp

# 해결: 명시적 크기 지정 (bwrap 은 직접 옵션 없음, mount 로 우회)
# Flatpak 등 상위 런타임에서 tmpfs 크기 설정 사용

디버깅 워크플로

# 1 단계: 최소 옵션으로 시작
$ bwrap --ro-bind / / --dev /dev --proc /proc -- /bin/sh

# 2 단계: 점진적 옵션 추가
$ bwrap --ro-bind / / --dev /dev --proc /proc --tmpfs /tmp -- /bin/sh
$ bwrap --ro-bind / / --dev /dev --proc /proc --tmpfs /tmp --unshare-net -- /bin/sh
$ bwrap --ro-bind / / --dev /dev --proc /proc --tmpfs /tmp --unshare-net --cap-drop-all -- /bin/sh

# 3 단계: 실패 지점 확인
$ strace -f -e trace=mount,open,execve bwrap ... 2>1 | grep -E "(ENOENT|EACCES|EPERM)"

# 4 단계: 커널 로그 확인
$ dmesg -w | grep -i "bwrap\|seccomp\|apparmor"

성능 벤치마크

시작 시간 오버헤드

Bubblewrap 의 시작 시간 오버헤드를 측정했습니다:

I/O 성능 비교

# 순차 읽기 테스트 (dd)
$ bwrap --ro-bind / / --tmpfs /tmp -- /bin/sh -c 'dd if=/dev/zero of=/tmp/test bs=1M count=1024'
1024+0 records in
1024+0 records out
1073741824 bytes (1.1 GB, 1.0 GiB) copied, 0.823 s, 1.3 GB/s

# 네이티브 비교
$ dd if=/dev/zero of=/tmp/test bs=1M count=1024
1024+0 records in
1024+0 records out
1073741824 bytes (1.1 GB, 1.0 GiB) copied, 0.815 s, 1.3 GB/s

bwrap 의 I/O 오버헤드는 1% 미만으로 무시할 수 있습니다. mount namespace 격리는 파일시스템 성능에 영향을 주지 않습니다.

메모리 오버헤드

# bwrap 프로세스 메모리 사용량
$ ps -o pid,rss,vsz,comm -C bwrap
  PID   RSS    VSZ COMMAND
12345  2048   3456 bwrap

# 네임스페이스당 커널 메모리 (대략적)
- User namespace:  ~8KB
- PID namespace:   ~4KB per process
- Mount namespace: ~2KB per mount point
- Net namespace:   ~32KB (socket buffers)

프로덕션 배포 체크리스트

보안 체크리스트

프로덕션 배포 예시

#!/bin/sh
# /usr/local/bin/run-sandboxed.sh

APP_NAME="myapp"
APP_BIN="/opt/${APP_NAME}/bin/${APP_NAME}"
APP_HOME="/opt/${APP_NAME}"
DATA_DIR="/var/lib/${APP_NAME}"
LOG_DIR="/var/log/${APP_NAME}"

exec bwrap \
    --unshare-all \
    --share-net \
    --ro-bind /usr /usr \
    --ro-bind /lib /lib \
    --ro-bind /lib64 /lib64 \
    --ro-bind /etc/ssl /etc/ssl \
    --ro-bind /etc/resolv.conf /etc/resolv.conf \
    --bind "${APP_HOME}" "${APP_HOME}" \
    --bind "${DATA_DIR}" "${DATA_DIR}" \
    --bind "${LOG_DIR}" "${LOG_DIR}" \
    --tmpfs /tmp \
    --tmpfs /var/tmp \
    --proc /proc \
    --dev /dev/null \
    --dev /dev/zero \
    --dev /dev/random \
    --dev /dev/urandom \
    --dev /dev/tty \
    --clearenv \
    --setenv PATH /usr/bin \
    --setenv HOME "${DATA_DIR}" \
    --setenv APP_HOME "${APP_HOME}" \
    --setenv LOG_DIR "${LOG_DIR}" \
    --cap-drop-all \
    --cap-add CAP_NET_BIND_SERVICE \
    --die-with-parent \
    --chdir "${APP_HOME}" \
    -- "${APP_BIN}" "\$@"

[Unit]
Description=MyApp Sandboxed Service
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/run-sandboxed.sh
Restart=on-failure
User=myapp
Group=myapp

# 추가 systemd 샌드박싱 (이중 보호)
ProtectSystem=strict
ProtectHome=yes
PrivateTmp=yes
NoNewPrivileges=yes

[Install]
WantedBy=multi-user.target

참고자료

• Bubblewrap GitHub Repository
• XDG Desktop Portal Documentation
• 네임스페이스 (Namespaces) — PID, mount, user, network 네임스페이스 상세
• Linux Containers & Docker — 컨테이너 런타임 비교
• LSM / Seccomp — Seccomp-BPF 필터 상세
• Kernel Seccomp Filter Documentation
• user_namespaces(7) — Linux man page
• CVE-2022-0185 — Linux Kernel Use-After-Free in fs_context