# Java 역직렬화 위험과 ObjectInputFilter: 허용한 클래스만 읽게 제한하기

> 직접 만든 연습용 클래스 Dangerous 의 readObject 가 필터 없이 실행되는 것을 확인하고, ObjectInputFilter 패턴 com.example.Safe;!* 로 거절되는 것을 비교합니다. maxdepth, maxarray, maxbytes 한도와 jdk.serialFilter 전역 설정, 허용 목록에서 자주 놓치는 클래스도 JDK 21 컨테이너에서 실행해 봅니다.

- 주소: https://copyandrun.com/blog/java-deserialization-objectinputfilter/
- 분야: 시큐어코딩
- 발행일: 2026-11-02
- 태그: Java, 역직렬화, ObjectInputFilter, JEP 290, jdk.serialFilter

Java 의 `ObjectInputStream` 은 바이트에 적힌 클래스 이름대로 객체를 만들고 그 클래스의 `readObject` 를 실행합니다. 신뢰할 수 없는 바이트를 필터 없이 읽으면 예상하지 않은 클래스까지 만들어지므로, 이 글에서는 `ObjectInputFilter`(JEP 290)로 읽을 클래스를 제한하는 방법을 직접 실행해 확인합니다.

Windows Git Bash 에서 Docker Desktop 으로 실행했습니다. 컨테이너는 `--network none` 으로 네트워크 없이 띄우므로 호스트 포트는 쓰지 않습니다. 코드는 직접 만든 연습용이며 `Dangerous` 클래스는 로그 한 줄만 출력합니다. 공격용 페이로드나 도구는 쓰지 않았고, 이 코드를 실제 서비스에 그대로 쓰지 않습니다.

## 준비물

| 항목 | 확인한 값 |
|---|---|
| 실행 환경 | Docker 컨테이너 1개, `eclipse-temurin:21-jdk` 이미지 |
| Java | OpenJDK 21.0.12 (Temurin-21.0.12+8) |
| 외부 라이브러리 | 없음(JDK 표준 라이브러리만 사용) |

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

```
Safe.java
Dangerous.java
Node.java
Blob.java
App.java
```

## 1. 컨테이너와 클래스 준비

<!-- files: Safe.java, Dangerous.java, Node.java, Blob.java, App.java -->

다섯 파일은 모두 `com.example` 패키지입니다. `Safe` 는 문자열과 숫자 필드만 가진 평범한 클래스이고, `Dangerous` 는 `readObject` 안에서 로그 한 줄을 출력하는 연습용 클래스입니다. `Node` 는 다음 노드를 가리키는 연결 구조(깊이 실험용), `Blob` 은 바이트 배열을 가진 클래스(크기 실험용)입니다. `App.java` 는 시나리오 이름을 받아 직렬화와 역직렬화를 수행합니다.

Git Bash 에서 `docker exec -w` 에 `/` 로 시작하는 경로를 넘기면 Windows 경로로 바뀌므로 먼저 `export MSYS_NO_PATHCONV=1` 을 실행합니다.

```bash
docker run -d --name cr-j27-lab --network none eclipse-temurin:21-jdk sleep 3600
docker exec cr-j27-lab mkdir -p /work
for f in *.java; do docker cp "$f" cr-j27-lab:/work/"$f"; done
docker exec -w /work cr-j27-lab javac -d out Safe.java Dangerous.java Node.java Blob.java App.java
docker exec -w /work cr-j27-lab java -version
docker exec -w /work cr-j27-lab ls out/com/example
```

![컨테이너가 떠 있고 JDK 21.0.12 로 다섯 클래스가 컴파일되어 out/com/example 에 .class 파일 다섯 개가 생긴 것을 확인합니다.](https://copyandrun.com/img/java-deserialization-objectinputfilter/01-lab-environment.png)

## 2. 필터가 없을 때와 있을 때 비교

<!-- files: App.java -->

`basic` 시나리오는 같은 `ObjectInputStream` 코드로 `Safe` 바이트와 `Dangerous` 바이트를 읽습니다. 앞의 두 번은 필터를 지정하지 않았고, 뒤의 두 번은 `setObjectInputFilter` 로 패턴 `com.example.Safe;!*` 를 지정했습니다. 패턴은 세미콜론으로 나누며 왼쪽부터 평가하고 처음 맞는 항목이 결과를 정합니다. `!` 가 붙으면 거절, 붙지 않으면 허용이고, 마지막의 `!*` 는 앞에서 허용하지 않은 나머지를 모두 거절합니다.

```bash
docker exec -w /work cr-j27-lab java -cp out com.example.App basic
```

![필터가 없으면 Dangerous 의 readObject 로그가 찍히며 객체가 만들어지고, 같은 바이트를 패턴 com.example.Safe;!* 로 읽으면 InvalidClassException 으로 거절되는 것을 확인합니다.](https://copyandrun.com/img/java-deserialization-objectinputfilter/02-basic-filter-compare.png)

필터가 없을 때는 `Dangerous` 바이트를 읽는 동안 `readObject` 가 실행되어 로그 줄이 나옵니다. 필터를 둔 쪽은 클래스 `Dangerous` 가 `!*` 에 걸려 `InvalidClassException: filter status: REJECTED` 가 나왔고 `readObject` 로그는 나오지 않았습니다. 공식 문서는 필터가 `REJECTED` 를 돌려주면 `readObject` 가 `InvalidClassException` 을 던진다고 설명합니다.

## 3. 읽은 뒤 형변환 검사는 늦습니다

<!-- files: App.java -->

`Safe s = (Safe) in.readObject();` 처럼 읽고 나서 타입을 검사하면 안전하다고 오해하기 쉽습니다. `cast` 시나리오는 `Dangerous` 바이트를 필터 없이 읽어 `Safe` 로 형변환합니다.

```bash
docker exec -w /work cr-j27-lab java -cp out com.example.App cast
```

![ClassCastException 이 나지만 그보다 먼저 Dangerous.readObject 로그가 이미 출력된 것을 확인합니다.](https://copyandrun.com/img/java-deserialization-objectinputfilter/03-cast-too-late.png)

형변환은 `readObject` 가 끝난 뒤에 일어나므로, 형변환이 실패하는 시점에는 `Dangerous` 의 `readObject` 가 이미 실행된 뒤입니다. 읽기 전에 막으려면 필터가 필요합니다.

## 4. 깊이, 배열 크기, 바이트 수 제한

<!-- files: App.java -->

패턴에는 클래스 규칙 외에 `maxdepth`(객체 그래프 깊이), `maxrefs`(내부 참조 수), `maxbytes`(스트림에서 읽은 바이트 수), `maxarray`(배열 길이) 한도를 `이름=값` 으로 넣을 수 있습니다. 한도를 넘으면 필터가 `REJECTED` 를 돌려줍니다. `limits` 시나리오는 `com.example.*` 를 허용하고 나머지를 거절하는 규칙에 한도를 더해, 3단계와 10단계 `Node`, 배열 100개와 5000개짜리 `Blob` 을 읽습니다.

```bash
docker exec -w /work cr-j27-lab java -cp out com.example.App limits
```

![maxdepth=5 에서 10단계 Node 가, maxarray=1000 에서 5000개 배열이, maxbytes=1000 에서 5180바이트 스트림이 거절되고 작은 객체는 통과하는 것을 확인합니다.](https://copyandrun.com/img/java-deserialization-objectinputfilter/04-depth-array-bytes-limits.png)

`Blob@3b764bce` 같은 해시 값은 실행할 때마다 달라집니다. `maxbytes` 는 필터가 검사하는 시점까지 읽은 바이트를 셉니다. 처음에는 `Blob` 에 `tail` 필드가 없어서 5000바이트 배열 하나만 있었는데 `maxbytes=1000` 에서 거절되지 않았습니다. 배열 길이를 검사하는 시점에는 아직 배열 내용을 읽기 전이라 읽은 바이트가 적었기 때문으로 보이고, 뒤에 `Safe` 필드(클래스 검사가 한 번 더 일어납니다)를 붙이자 거절되었습니다. 크기 제한에는 `maxarray` 처럼 항목 단위 한도를 함께 쓰는 편이 안전합니다.

## 5. JVM 전역 필터 jdk.serialFilter

<!-- files: App.java -->

코드를 고치지 않고 모든 `ObjectInputStream` 에 같은 규칙을 적용하려면 시스템 속성 `jdk.serialFilter` 를 씁니다. `$JAVA_HOME/conf/security/java.security` 파일의 같은 이름 보안 속성으로도 지정할 수 있고, 둘 다 있으면 시스템 속성이 우선한다고 공식 문서에 있습니다. `global` 시나리오는 `setObjectInputFilter` 를 호출하지 않고 읽습니다.

```bash
docker exec -w /work cr-j27-lab java "-Djdk.serialFilter=com.example.Safe;!*" -cp out com.example.App global
```

![코드에서 필터를 지정하지 않았는데도 Dangerous 바이트가 거절되고 Safe 바이트는 읽히는 것을 확인합니다.](https://copyandrun.com/img/java-deserialization-objectinputfilter/05-jvm-wide-filter.png)

전역 필터는 모든 스트림에 걸리므로 라이브러리가 읽는 클래스도 영향을 받습니다. 운영 전에 어떤 클래스가 읽히는지 확인하고 허용 목록을 정합니다.

## 6. 허용 목록에서 놓치기 쉬운 것

<!-- files: App.java -->

`pitfall` 시나리오는 두 가지를 확인합니다. 첫째, 마지막 `!*` 를 빼면 어떻게 되는지입니다. 둘째, `Safe` 객체를 `ArrayList` 에 담아 직렬화하면 규칙에 무엇을 더해야 하는지입니다.

```bash
docker exec -w /work cr-j27-lab java -cp out com.example.App pitfall
```

![패턴에 !* 가 없으면 Dangerous 가 그대로 읽히고, ArrayList 에 담은 Safe 는 java.util.ArrayList 와 java.lang.Object 까지 허용해야 읽히는 것을 확인합니다.](https://copyandrun.com/img/java-deserialization-objectinputfilter/06-allowlist-pitfalls.png)

공식 문서는 어떤 패턴에도 맞지 않는 클래스는 허용된다고 설명하므로, 허용 목록으로 쓰려면 `!*` 를 마지막에 둬야 합니다. 목록 안의 객체까지 읽으려면 컬렉션 클래스도 허용해야 합니다. 이 실행에서는 `java.util.ArrayList` 만 허용하면 여전히 거절되었고 `java.lang.Object` 를 더하자 읽혔습니다. 내부 배열(`Object[]`)의 원소 타입이 검사되었기 때문으로 보입니다. 허용 범위를 넓히는 일이므로 컬렉션이 필요한지부터 따져 봅니다.

## 결과 정리

- 필터가 없으면 `ObjectInputStream` 은 바이트가 가리키는 클래스를 만들고 `readObject` 를 실행합니다. 읽은 뒤의 형변환 검사는 늦습니다.
- 허용 목록은 `com.example.Safe;!*` 처럼 허용할 클래스를 앞에, `!*` 를 마지막에 둡니다.
- `maxdepth`, `maxarray`, `maxbytes` 로 그래프의 복잡도와 크기를 제한하고, `jdk.serialFilter` 로 코드 수정 없이 JVM 전체에 적용할 수 있습니다.
- 신뢰할 수 없는 입력에는 Java 직렬화 대신 JSON 처럼 데이터만 담는 형식을 쓰는 쪽이 낫습니다. 필터는 형식을 바꿀 수 없을 때의 방어선으로 둡니다.

## 전체 코드

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

```
Safe.java
Dangerous.java
Node.java
Blob.java
App.java
```

### Safe.java

```java
package com.example;

import java.io.Serializable;

public class Safe implements Serializable {
    private static final long serialVersionUID = 1L;

    public final String name;
    public final int count;

    public Safe(String name, int count) {
        this.name = name;
        this.count = count;
    }

    @Override
    public String toString() {
        return "Safe[name=" + name + ", count=" + count + "]";
    }
}
```

### Dangerous.java

```java
package com.example;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;

// 연습용 클래스입니다. readObject 에서 로그 한 줄만 남기며, 그 외에는 아무 일도 하지 않습니다.
public class Dangerous implements Serializable {
    private static final long serialVersionUID = 1L;

    public final String note;

    public Dangerous(String note) {
        this.note = note;
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        in.defaultReadObject();
        System.out.println("  [Dangerous.readObject] 역직렬화 중에 이 코드가 실행되었습니다. note=" + note);
    }

    @Override
    public String toString() {
        return "Dangerous[note=" + note + "]";
    }
}
```

### Node.java

```java
package com.example;

import java.io.Serializable;

public class Node implements Serializable {
    private static final long serialVersionUID = 1L;

    public final String label;
    public final Node next;

    public Node(String label, Node next) {
        this.label = label;
        this.next = next;
    }

    public static Node chain(int length) {
        Node head = null;
        for (int i = length; i >= 1; i--) {
            head = new Node("n" + i, head);
        }
        return head;
    }
}
```

### Blob.java

```java
package com.example;

import java.io.Serializable;

public class Blob implements Serializable {
    private static final long serialVersionUID = 1L;

    public final byte[] data;
    public final Safe tail = new Safe("tail", 0);

    public Blob(int size) {
        this.data = new byte[size];
    }
}
```

### App.java

```java
package com.example;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InvalidClassException;
import java.io.ObjectInputFilter;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

public class App {
    static byte[] toBytes(Object o) throws Exception {
        ByteArrayOutputStream buf = new ByteArrayOutputStream();
        try (ObjectOutputStream out = new ObjectOutputStream(buf)) {
            out.writeObject(o);
        }
        return buf.toByteArray();
    }

    // pattern 이 null 이면 필터를 따로 지정하지 않습니다(JVM 전역 필터가 있으면 그것이 적용됩니다).
    static void tryRead(String title, byte[] data, String pattern) {
        System.out.println("== " + title + " | 필터: " + (pattern == null ? "지정 안 함" : pattern) + " | " + data.length + " bytes");
        try (ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(data))) {
            if (pattern != null) {
                in.setObjectInputFilter(ObjectInputFilter.Config.createFilter(pattern));
            }
            Object o = in.readObject();
            System.out.println("  결과: " + o.getClass().getSimpleName() + " 객체가 만들어졌습니다. " + (o instanceof Node ? "" : o));
        } catch (InvalidClassException e) {
            System.out.println("  거절됨: InvalidClassException " + e.getMessage());
        } catch (Exception e) {
            System.out.println("  오류: " + e);
        }
    }

    public static void main(String[] args) throws Exception {
        String scenario = args.length > 0 ? args[0] : "basic";
        byte[] safe = toBytes(new Safe("report", 3));
        byte[] dangerous = toBytes(new Dangerous("연습용 데이터"));

        switch (scenario) {
            case "basic" -> {
                String allow = "com.example.Safe;!*";
                tryRead("Safe 바이트", safe, null);
                tryRead("Dangerous 바이트", dangerous, null);
                tryRead("Safe 바이트", safe, allow);
                tryRead("Dangerous 바이트", dangerous, allow);
            }
            case "cast" -> {
                System.out.println("== Dangerous 바이트를 필터 없이 읽고 Safe 로 형변환");
                try (ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(dangerous))) {
                    Safe s = (Safe) in.readObject();
                    System.out.println("  " + s);
                } catch (ClassCastException e) {
                    System.out.println("  형변환 실패: ClassCastException (readObject 코드는 이미 실행된 뒤입니다)");
                }
            }
            case "limits" -> {
                String rule = "maxdepth=5;maxarray=1000;com.example.*;!*";
                tryRead("Node 3단계", toBytes(Node.chain(3)), rule);
                tryRead("Node 10단계", toBytes(Node.chain(10)), rule);
                tryRead("Blob 배열 100개", toBytes(new Blob(100)), rule);
                tryRead("Blob 배열 5000개", toBytes(new Blob(5000)), rule);
                String bytesRule = "maxbytes=1000;com.example.*;!*";
                tryRead("Blob 배열 100개", toBytes(new Blob(100)), bytesRule);
                tryRead("Blob 배열 5000개", toBytes(new Blob(5000)), bytesRule);
            }
            case "pitfall" -> {
                tryRead("Dangerous 바이트", dangerous, "com.example.Safe");
                byte[] list = toBytes(new ArrayList<>(List.of(new Safe("a", 1), new Safe("b", 2))));
                tryRead("Safe 목록(ArrayList)", list, "com.example.Safe;!*");
                tryRead("Safe 목록(ArrayList)", list, "com.example.Safe;java.util.ArrayList;java.lang.Object;!*");
            }
            case "global" -> {
                System.out.println("== JVM 전역 필터: " + ObjectInputFilter.Config.getSerialFilter());
                tryRead("Safe 바이트", safe, null);
                tryRead("Dangerous 바이트", dangerous, null);
            }
            default -> System.out.println("사용법: App basic | cast | limits | pitfall | global");
        }
    }
}
```

## 자주 막히는 곳

- **`docker exec -w /work` 의 경로가 Windows 경로로 바뀝니다.** Git Bash 의 경로 변환 때문입니다. `export MSYS_NO_PATHCONV=1` 을 먼저 실행합니다.
- **패턴 끝에 `!*` 가 없으면 아무것도 막히지 않습니다.** 6단계에서 `com.example.Safe` 만 지정했더니 `Dangerous` 가 그대로 읽혔습니다.
- **`ArrayList` 에 담은 `Safe` 가 거절됩니다.** `com.example.Safe;!*` 에서는 `ArrayList` 자체가 `!*` 에 걸렸고, `java.util.ArrayList` 를 더해도 `java.lang.Object` 를 허용하기 전까지 거절되었습니다.
- **`maxbytes` 만으로 큰 배열이 거절되지 않았습니다.** 4단계처럼 검사 시점에 읽은 바이트만 세기 때문으로 보이므로, 배열 길이는 `maxarray` 로 따로 제한합니다.
- **`-Djdk.serialFilter` 값의 `;` 를 셸이 명령 구분자로 읽습니다.** 옵션 전체를 따옴표로 감쌉니다(5단계의 명령처럼).

## 확인 범위

- **확인한 것:** 위의 모든 명령과 출력은 `eclipse-temurin:21-jdk`(OpenJDK 21.0.12) 컨테이너에서 실행한 결과입니다. 패턴 문법, 한도 이름, 평가 순서, 거절 시 `InvalidClassException` 은 `https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/io/ObjectInputFilter.Config.html` 과 `https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/io/ObjectInputStream.html`, 패턴 필터 규칙과 `jdk.serialFilter` 는 `https://docs.oracle.com/en/java/javase/21/core/creating-pattern-based-filters.html` 에서 확인했습니다. Java Serialization Filtering 가이드 첫 페이지는 개요만 있어 세부 내용은 하위 페이지에서 확인했습니다.
- **하지 못한 것:** Java 17 에서는 실행하지 않았습니다(코드의 `switch` 화살표 문법은 14 이상이면 컴파일됩니다). 필터 팩토리(`setSerialFilterFactory`), 필터 로깅, `java.security` 파일 편집, Linux 와 macOS 셸은 실행하지 않았습니다.
- **범위의 한계:** 이 글은 직접 만든 무해한 클래스로 동작 원리만 보여 줍니다. 실제 라이브러리 조합에서의 위험 평가, 외부 프레임워크가 쓰는 역직렬화 경로(RMI, JMX 등)는 다루지 않습니다. `maxbytes` 가 검사 시점까지의 바이트만 센다는 해석은 실행 결과에서 본 것이며 JDK 소스로 확인하지 않았습니다.
