Abseil Code Review · 26/79

Abseil Escape — CEscape·HexEscape·Base64

2026년 6월 10일 · Hawk · 3분 읽기

#한 줄 요약

문자열을 안전한 표현으로 바꾸는 두 갈래가 있다. 사람이 읽을 표현(CEscape, HexEscape)과 전송용 인코딩(Base64Escape). Abseil은 모두 absl/strings/escaping.h 한 헤더에 통합 제공하며, web-safe variant, padding 옵션, in-place reverse 함수까지 지원한다.

#동기

log 출력, 디버깅 dump, 직렬화. 임의 바이트 문자열을 사람이 읽거나 텍스트 전송하려면 escape가 필요하다. 표준 라이브러리에는 명확한 helper가 없다 — iomanip의 std::hex는 단일 정수용이고, base64는 표준에 없다.

1
// 회피 — 로그에 raw bytes
2
LOG(INFO) << "buffer: " << raw_data;  // 제어 문자, NUL, non-printable이 그대로
3

4
// Good
5
LOG(INFO) << "buffer: " << absl::CEscape(raw_data);
6
// "buffer: hello\x00world\n"

#API와 사용법

1
#include "absl/strings/escaping.h"
2

3
namespace absl {
4
// C-style escape: \n, \t, \xHH, \\
5
std::string CEscape(absl::string_view src);
6
std::string CHexEscape(absl::string_view src);   // 모든 non-printable을 \x로
7
bool CUnescape(absl::string_view src, std::string* dest, std::string* error = nullptr);
8

9
// 16진 문자열
10
std::string BytesToHexString(absl::string_view from);
11
std::string HexStringToBytes(absl::string_view from);
12

13
// Base64 (RFC 4648 표준 alphabet)
14
void Base64Escape(absl::string_view src, std::string* dest);
15
std::string Base64Escape(absl::string_view src);
16
bool Base64Unescape(absl::string_view src, std::string* dest);
17

18
// Web-safe Base64 (URL/filename 안전 alphabet)
19
void WebSafeBase64Escape(absl::string_view src, std::string* dest);
20
std::string WebSafeBase64Escape(absl::string_view src);
21
bool WebSafeBase64Unescape(absl::string_view src, std::string* dest);
22
}

#CEscape — C 스타일 이스케이프

1
std::string s = absl::CEscape("hello\x01world\n");
2
// "hello\\x01world\\n"

규칙은 다음과 같다.

\n, \r, \t, \\, \", \'는 backslash 이스케이프.
printable ASCII는 그대로.
non-printable은 \xHH(2자리 16진).

CHexEscape는 더 엄격하다. printable이라도 8진 escape 가능 character까지 모두 \xHH로 출력한다. 디버깅/binary dump에 적합.

1
absl::CEscape("\x07ABC");     // "\\aABC"      (\\a = BEL)
2
absl::CHexEscape("\x07ABC");  // "\\x07ABC"

CUnescape는 역변환. 파싱 에러는 error 문자열에 담아 반환한다.

1
std::string out, err;
2
if (!absl::CUnescape("hello\\x01world", &out, &err)) {
3
  LOG(ERROR) << "unescape failed: " << err;
4
}

#HexString — 단순 16진

1
std::string hex = absl::BytesToHexString("\x00\xff\x10");
2
// "00ff10"
3

4
std::string bytes = absl::HexStringToBytes("DEADBEEF");
5
// "\xde\xad\xbe\xef"  (소문자/대문자 모두 허용)

체크섬, hash 값, 메모리 dump 등 완전 16진이 필요할 때 쓴다. CHexEscape는 사람이 읽기 위해 printable과 섞이고, BytesToHexString은 순수 16진이다.

#Base64

1
std::string encoded;
2
absl::Base64Escape("hello world", &encoded);
3
// "aGVsbG8gd29ybGQ="

표준 alphabet A–Z a–z 0–9 + /와 = padding. RFC 4648 준수.

1
std::string decoded;
2
if (!absl::Base64Unescape(encoded, &decoded)) {
3
  // invalid base64
4
}

엄격하다. 잘못된 문자, 패딩 누락, 길이 mismatch는 false. raw 바이트가 임의 0x00을 포함해도 안전.

#WebSafeBase64 — URL/filename 안전

표준 base64의 +와 /는 URL/filename에서 escape가 필요하다. WebSafe variant는 alphabet을 바꾼다.

1
표준:    A-Z a-z 0-9 + / =
2
WebSafe: A-Z a-z 0-9 - _ =

1
std::string token;
2
absl::WebSafeBase64Escape(raw_uuid_bytes, &token);
3
// URL safe — query string, path, cookie에 그대로 사용 가능

WebSafeBase64Unescape도 대칭. 표준 base64로 인코딩된 문자열을 web-safe로 디코딩하려고 하면 false다(+ / 미허용).

padding = 처리 차이도 알아두면 좋다. JWT 등 일부 protocol은 padding 없는 WebSafeBase64를 쓴다 — absl::WebSafeBase64Unescape는 padding 있음/없음 모두 허용한다(Escape 측은 padding을 붙인다).

#내부 구현

Base64는 6-bit 단위 lookup table로 동작한다. 핵심 인코더는 다음과 같은 구조다.

1
// absl/strings/escaping.cc (요약)
2
constexpr char kBase64Chars[] =
3
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
4

5
constexpr char kWebSafeBase64Chars[] =
6
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
7

8
size_t Base64EscapeInternal(const unsigned char* src, size_t slen,
9
                            char* dest, size_t szdest,
10
                            const char* base64, bool do_padding) {
11
  // 3 bytes → 4 chars 반복
12
  // 마지막 1~2 bytes 처리 + 옵션 padding
13
}

알고리즘은 같고 alphabet과 padding만 다르다. 두 함수 모두 한 번의 alloc(또는 dest reserve)으로 끝난다.

CEscape는 byte 단위 상태 머신이다. lookup 없이 단순 if 분기로 처리. 작은 입력에서 가장 빠른 경로다.

#코드 리뷰 포인트

1. log/error message의 raw bytes

1
// 회피 — 제어 문자가 터미널을 깨뜨림, NUL이 잘림
2
LOG(ERROR) << "got: " << buffer;
3

4
// Good
5
LOG(ERROR) << "got: " << absl::CEscape(buffer);

2. URL token 생성

1
// 회피 — 표준 base64는 URL에 부적합
2
std::string token;
3
absl::Base64Escape(secret_bytes, &token);
4
// "+/" 등이 들어가면 URL escape가 또 필요
5

6
// Good
7
std::string token;
8
absl::WebSafeBase64Escape(secret_bytes, &token);
9
// 그대로 URL에 사용

3. config dump

1
// 사람이 읽기 좋은 형식
2
for (const auto& [k, v] : config) {
3
  LOG(INFO) << absl::StrCat("  ", k, " = \"", absl::CEscape(v), "\"");
4
}

#안티패턴

HexString vs CHexEscape 혼동

함수	출력	용도
`BytesToHexString("AB")`	`"4142"`	순수 16진 (해시값, 체크섬)
`CHexEscape("AB")`	`"AB"`	C 리터럴 호환 (printable은 그대로)
`CHexEscape("\x01")`	`"\\x01"`	디버깅 dump

두 API의 의미가 다르다. 항상 의도와 일치하는 쪽을 고른다.

unsafe alphabet 가정

base64 결과를 문자열 그대로 SQL/HTML/log에 넣을 때 검증 없이 그러지 않는다. 표준 base64는 SQL injection 측면에서는 안전한 문자만 쓰지만, /가 path traversal 위험이 있는 환경(파일명 등)에서는 위험할 수 있다. WebSafe를 쓴다.

padding 처리 가정

1
// 회피 — padding 형식 가정
2
assert(encoded.size() % 4 == 0);
3

4
// Good — Unescape 결과만 검증
5
std::string out;
6
if (!absl::WebSafeBase64Unescape(encoded, &out)) {
7
  return InvalidInput();
8
}