해설 — 채팅 패킷 문자열 길이의 단위 혼동 (C++)

난이도: 중상

요약

스펙은 msgLen 을 UTF-8 바이트 수로 정의했고 std::string::size() 는 이미 바이트 수인데, 코드는 굳이 messageLength() 라는 자체 계산을 끼워 넣었다. 그런데 그 함수의 if (c >= 0xC0) 는 char 가 부호 있는 타입인 대부분의 플랫폼(x86/x86-64 Linux·Windows)에서 절대 참이 되지 않는다. 결과적으로 이 함수는 ASCII 문자 수만 세고, 한글/이모지는 하나도 세지 않는다. 이 값이 인코더의 msgLen 과 디코더의 소비 바이트 수로 그대로 쓰이면서 스트림 프레임이 통째로 어긋난다. 여기에 substr 바이트 절단이 UTF-8 시퀀스를 반으로 가르고, memcpy(..., n * sizeof(wchar_t)) 는 소스 길이의 4배를 읽는 힙 과다 읽기다.

문제점

(A) 길이 계산 자체가 틀렸다 — 부호 있는 char 비교와 단위 혼동

• 분류: 정수 부호/승격 오류 · 프로토콜 스펙 위반 · 프레임 desync

• 증상:

  • char c = s[i]; 에서 c 는 대부분 signed char 다. c >= 0xC0 에서 c 는 int 로 정수 승격되는데, UTF-8 시작 바이트 0xEC 는 signed char 로 -20 이므로 -20 >= 192 는 거짓이다. 한글·일본어·이모지의 시작 바이트가 한 번도 세어지지 않는다.
  • 반면 바로 위의 (c & 0x80) == 0 은 비트 연산이라 의도대로 동작한다. 그래서 ASCII 만 세고 나머지는 전부 0으로 계산된다. "안녕하세요" → messageLength() 가 0 을 돌려준다.
  • encode() 는 이 0 을 msgLen 에 넣고 바디는 15바이트를 붙여 보낸다. 수신 측이 스펙대로 msgLen 바이트를 읽으면 빈 문자열을 얻고, 남은 15바이트를 다음 패킷 헤더로 해석한다. 연결이 끊길 때까지 모든 후속 패킷이 어긋난다.
  • tryDecode() 의 p += len 도 같다. msgLen 바이트를 읽어놓고 0바이트만 전진하므로 consumed 가 프레임 길이보다 작고, 꼬리 바이트가 누적 버퍼에 남아 스스로 desync 를 만든다.
  • 상한 검사 len > kMaxMsgLen 도 무력화된다. 한글 60,000바이트 메시지의 len 은 0 이라 어떤 길이 제한도 걸리지 않는다.

• 재현 조건: 비ASCII 문자가 하나라도 포함된 채팅. 영문 QA 환경에서는 len == s.size() 라 절대 재현되지 않는다.

• 근본 원인:

  1. char 의 부호는 구현 정의(implementation-defined) 다. ARM 리눅스는 기본이 unsigned 라 같은 코드가 플랫폼마다 다르게 동작한다. 바이트를 값으로 비교할 때는 반드시 unsigned char(또는 std::uint8_t)로 캐스팅해야 한다.
  2. 애초에 이 계산이 필요 없다. 스펙 단위가 바이트인데 std::string::size() 가 바로 그 값이다. 불필요한 자체 구현이 버그를 들여왔다.
  3. C# 쪽과 달리 C++ 의 std::string 은 이미 바이트 컨테이너라, 반대로 "코드포인트 수"가 필요한 상황(UI 표시 길이)과 헷갈리기 쉽다. 두 단위를 이름으로 구분하지 않은 것이 원인이다.

• 여기에 경계 검증이 빠져 있다. tryDecode 는 avail < 2 + payloadLen 만 보고 msgLen 이 payloadLen 안에 들어가는지는 확인하지 않는다. 악성 클라가 payloadLen = 4, msgLen = 60000 을 보내면 std::string text(reinterpret_cast<const char*>(buf + p), 60000) 이 수신 버퍼 밖 60KB 를 그대로 읽는다. 힙 과다 읽기 → 인접 세션 데이터 유출 또는 SIGSEGV. 길이 필드는 "상한"과 "상위 프레임 안에 들어맞는가"를 둘 다 검사해야 한다.

(B) 자르기와 복사가 바이트/요소 단위를 뒤섞는다

• 분류: 인코딩 처리 오류 · 버퍼 과다 읽기(out-of-bounds read) · 오프바이원
• 증상:
  • text.substr(0, kMaxMsgLen) 은 정확히 256바이트에서 자른다. 그 자리가 3바이트 한글이나 4바이트 이모지의 중간이면 결과 문자열 끝에 잘린 시퀀스가 남는다. 관대한 클라는 `` 를 그리고, 엄격한 클라(throwOnInvalidBytes, Rust String::from_utf8)는 역직렬화 예외로 접속을 끊는다. "한글 채팅을 길게 치면 가끔 튕긴다"는 형태로 보고된다.
  • copyToWideBuffer 는 n 을 text.size()(바이트 수)로 잡아놓고 memcpy(dst, text.data(), n * sizeof(wchar_t)) 로 복사한다. 소스는 n 바이트뿐인데 4n 바이트(리눅스 wchar_t = 4바이트)를 읽는다. 소스 길이의 4배를 읽는 힙 과다 읽기다. ASAN 없이는 대부분 조용히 통과하다가, 문자열이 힙 페이지 끝에 놓이는 순간 크래시한다.
  • 목적지 쪽도 안전하지 않다. n <= dstCount 로만 제한하고 4n 바이트를 쓰므로 dstCount 요소짜리 버퍼(= 4*dstCount 바이트)를 딱 채우고, 이어지는 dst[n] = L'\0' 이 n == dstCount 일 때 버퍼 밖에 널을 쓴다(오프바이원 스택/힙 오버플로).
  • 설령 크래시하지 않아도 결과는 무의미하다. UTF-8 바이트를 wchar_t 슬롯에 그대로 밀어 넣은 것이라 어떤 인코딩도 아니다. 운영툴에는 깨진 글자만 뜬다.
• 재현 조건: 256바이트를 넘는 다국어 메시지 / 힙 페이지 경계에 걸린 문자열 / ASAN 빌드.
• 근본 원인:
  1. substr 은 바이트 인덱스로 동작하며 UTF-8 경계를 전혀 모른다.
  2. memcpy 의 세 번째 인자는 바이트 수인데, 소스와 목적지의 요소 크기가 다른데도 sizeof(wchar_t) 를 한쪽 기준으로만 곱했다. 요소 크기가 다른 두 버퍼 사이에는 memcpy 자체가 잘못된 도구다(변환이 필요하다).
  3. wchar_t 는 크기가 플랫폼마다 다르다(Windows 2바이트/UTF-16, Linux 4바이트/UTF-32). 크로스 플랫폼 코드에서 wchar_t 를 쓰는 것 자체가 위험 신호다.

수정안

핵심은 ① 길이는 std::string::size()(바이트) 하나로 통일, ② 바이트 비교는 unsigned char 로, ③ 길이 필드의 내부 정합성 + UTF-8 유효성 검증, ④ 자르기는 시퀀스 경계에서, ⑤ 넓은 문자로 옮길 때는 memcpy 가 아니라 디코딩.

아래 코드는 g++ -std=c++17 -pthread -Wall 로 검증했다.

constexpr std::size_t kMaxMsgLen = 256;   // UTF-8 바이트 수 상한

// 반드시 unsigned char 로 비교한다.
inline bool isContinuation(unsigned char b) { return (b & 0xC0) == 0x80; }

// 표시 길이용 코드포인트 수 (전송 길이가 아니다 — 이름으로 단위를 구분한다)
inline std::size_t codePointCount(const std::string& s) {
    std::size_t n = 0;
    for (unsigned char b : s) if (!isContinuation(b)) ++n;
    return n;
}

// 엄격 UTF-8 검증: 잘린 시퀀스·오버롱·서로게이트·범위를 모두 본다.
inline bool validateUtf8(const std::string& s) {
    std::size_t i = 0, n = s.size();
    while (i < n) {
        unsigned char b0 = static_cast<unsigned char>(s[i]);
        std::size_t extra;
        std::uint32_t cp;
        if (b0 < 0x80)                    { extra = 0; cp = b0; }
        else if ((b0 & 0xE0) == 0xC0)     { extra = 1; cp = b0 & 0x1Fu; }
        else if ((b0 & 0xF0) == 0xE0)     { extra = 2; cp = b0 & 0x0Fu; }
        else if ((b0 & 0xF8) == 0xF0)     { extra = 3; cp = b0 & 0x07u; }
        else                              return false;
        if (i + extra >= n) return false;                 // 잘린 시퀀스
        for (std::size_t k = 1; k <= extra; ++k) {
            unsigned char bk = static_cast<unsigned char>(s[i + k]);
            if (!isContinuation(bk)) return false;
            cp = (cp << 6) | (bk & 0x3Fu);
        }
        if (extra == 1 && cp < 0x80)      return false;   // 오버롱
        if (extra == 2 && cp < 0x800)     return false;
        if (extra == 3 && cp < 0x10000)   return false;
        if (cp > 0x10FFFF)                return false;
        if (cp >= 0xD800 && cp <= 0xDFFF) return false;   // 서로게이트
        i += extra + 1;
    }
    return true;
}

// 바이트 상한을 지키되 멀티바이트 시퀀스 중간에서 자르지 않는다.
inline std::string truncateUtf8(const std::string& s, std::size_t maxBytes) {
    if (s.size() <= maxBytes) return s;
    std::size_t cut = maxBytes;
    while (cut > 0 && isContinuation(static_cast<unsigned char>(s[cut]))) --cut;
    return s.substr(0, cut);
}

bool tryDecode(const std::uint8_t* buf, std::size_t avail,
               ChatMessage& out, std::size_t& consumed)
{
    consumed = 0;
    if (avail < 2) return false;

    std::uint16_t payloadLen = 0;
    std::memcpy(&payloadLen, buf, 2);
    if (payloadLen < 3) throw std::runtime_error("payload too small");
    if (avail < static_cast<std::size_t>(2) + payloadLen) return false;   // 아직 다 안 옴

    std::size_t p = 2;
    std::uint8_t channel = buf[p]; p += 1;
    std::uint16_t msgLen = 0;
    std::memcpy(&msgLen, buf + p, 2); p += 2;

    // ① 상한 ② 상위 프레임 정합성 — 둘 다 필요
    if (msgLen > kMaxMsgLen)      throw std::runtime_error("message too long");
    if (msgLen != payloadLen - 3) throw std::runtime_error("msgLen mismatch");

    std::string text(reinterpret_cast<const char*>(buf + p), msgLen);
    if (!validateUtf8(text))      throw std::runtime_error("invalid utf-8");

    out.channel = channel;
    out.text    = std::move(text);
    consumed    = static_cast<std::size_t>(2) + payloadLen;   // 소비량은 프레임 길이로 확정
    return true;
}

std::vector<std::uint8_t> encode(const ChatMessage& msg)
{
    const std::string text = truncateUtf8(msg.text, kMaxMsgLen);

    const std::uint16_t msgLen     = static_cast<std::uint16_t>(text.size());   // 바이트 수
    const std::uint16_t payloadLen = static_cast<std::uint16_t>(1 + 2 + text.size());

    std::vector<std::uint8_t> outBuf(static_cast<std::size_t>(2) + payloadLen);
    std::size_t p = 0;
    std::memcpy(outBuf.data() + p, &payloadLen, 2); p += 2;
    outBuf[p] = msg.channel; p += 1;
    std::memcpy(outBuf.data() + p, &msgLen, 2); p += 2;
    std::memcpy(outBuf.data() + p, text.data(), text.size());
    return outBuf;
}

넓은 문자 버퍼로 옮길 때는 바이트를 밀어 넣는 게 아니라 디코딩한다. 플랫폼마다 크기가 다른 wchar_t 대신 char32_t 를 쓰는 편이 안전하다.

inline std::vector<char32_t> toUtf32(const std::string& s) {
    std::vector<char32_t> out;
    out.reserve(s.size());
    std::size_t i = 0;
    while (i < s.size()) {
        unsigned char b0 = static_cast<unsigned char>(s[i]);
        std::size_t extra = (b0 < 0x80) ? 0 : ((b0 & 0xE0) == 0xC0) ? 1
                          : ((b0 & 0xF0) == 0xE0) ? 2 : 3;
        std::uint32_t cp = (extra == 0) ? b0 : (b0 & (0x3Fu >> extra));
        for (std::size_t k = 1; k <= extra; ++k)
            cp = (cp << 6) | (static_cast<unsigned char>(s[i + k]) & 0x3Fu);
        out.push_back(static_cast<char32_t>(cp));
        i += extra + 1;
    }
    return out;
}

// 고정 크기 버퍼로 복사할 때는 "요소 수" 단위로 계산하고 널 자리를 남긴다.
inline std::size_t copyToWideBuffer(const std::string& text, char32_t* dst, std::size_t dstCount) {
    if (dstCount == 0) return 0;
    const std::vector<char32_t> cps = toUtf32(text);   // 반드시 validateUtf8 통과 후 호출
    std::size_t n = cps.size();
    if (n > dstCount - 1) n = dstCount - 1;            // 널 종료 자리 확보
    std::memcpy(dst, cps.data(), n * sizeof(char32_t));
    dst[n] = U'\0';
    return n;
}

더 나은 설계

(1) 검증된 UTF-8 만 담는 타입(Utf8Text)을 만들어 프로토콜 경계에서 강제한다. 생성자에서만 validateUtf8 을 통과시키고, 이후 코드는 size()(바이트)와 codePointCount()(표시 길이)를 이름으로 구분해 쓴다. 검증되지 않은 std::string 이 직렬화기에 들어갈 길 자체를 없앤다.

• 트레이드오프: 타입이 하나 늘고 변환 지점이 생긴다. 대신 "검증했나?"를 매번 되묻지 않아도 되고, 단위 혼동이 타입 시스템에서 잡힌다.

(2) 코덱을 손으로 쓰지 말고 IDL(FlatBuffers/Protobuf/사내 IDL)에서 생성한다. 길이 단위·엔디안·경계 검증이 생성기 한 곳에만 있으므로 서버/클라가 어긋날 수 없다. FlatBuffers 의 Verifier 처럼 신뢰할 수 없는 입력 검증이 기본 제공되는 것도 크다.

• 트레이드오프: 빌드 파이프라인과 스키마 버저닝이 필요하고, 바이트 레이아웃을 손으로 최적화하기 어렵다. 하지만 이 문제 유형(과다 읽기, 단위 혼동)이 통째로 사라진다.

(3) 텍스트 처리 전반을 ICU 또는 검증된 소형 라이브러리(utfcpp, simdutf)로 위임한다. 자소 클러스터 경계 자르기, 정규화, 유효성 검증을 직접 짜면 언젠가 반드시 틀린다. 특히 👨‍👩‍👧 같은 ZWJ 이모지는 코드포인트 경계로 잘라도 깨지므로 자소 클러스터 API 가 필요하다.

• 트레이드오프: ICU 는 바이너리가 크고 빌드가 무겁다. 게임서버라면 채팅 게이트웨이 프로세스에만 넣고 존 서버는 검증된 바이트만 다루게 분리하는 절충이 흔하다.

면접 포인트

• "char 로 UTF-8 바이트를 비교할 때 무엇이 위험한가?" — char 의 부호는 구현 정의다. x86 Linux 는 signed 라 c >= 0x80 이 항상 거짓이고, ARM Linux 는 unsigned 라 참이 된다. 같은 코드가 플랫폼마다 다르게 동작한다. 바이트 값 비교는 항상 unsigned char/std::uint8_t.
• "std::string::size() 는 무엇을 세는가?" — 바이트 수다. 코드포인트 수도 자소 수도 아니다. 전송 길이는 바이트, UI 길이는 자소 — 단위를 함수 이름으로 구분하는 것이 실무 습관이다.
• "요소 크기가 다른 두 버퍼 사이에 memcpy 를 쓸 수 있는가?" — 없다. n * sizeof(dst_elem) 로 소스를 읽는 순간 소스 범위를 넘는다. 인코딩이 다르면 복사가 아니라 변환이 필요하다.
• "신뢰할 수 없는 입력의 길이 필드는 어떻게 검사하는가?" — 상한 검사만으로는 부족하고, 상위 프레임 안에 들어맞는지까지 봐야 한다. 이 검사 하나가 빠지면 힙 과다 읽기로 다른 세션의 평문이 그대로 흘러나간다.