터미널 ANSI 이스케이프 코드 완전 정리

리눅스 커널 개발자가 알아야 할 모든 ANSI 이스케이프 시퀀스. 커서 제어, 텍스트 색상, 256/RGB 컬러, 터미널 초기화까지 실전 예제와 함께 정리했습니다.

개요

ANSI 이스케이프 시퀀스 (ANSI Escape Sequence)는 터미널 에뮬레이터에서 커서 이동, 텍스트 색상 변경, 화면 제어 등을 수행하기 위한 표준화된 제어 코드입니다. 1981 년 ANSI X3.64 표준으로 제정된 이후 VT100 터미널을 거쳐 현대의 xterm, Linux terminal, macOS Terminal.app 까지 모든 터미널에서 지원됩니다.

리눅스 커널 개발 과정에서 printk() 로그에 색상을 추가하거나, 커널 모듈 (Kernel Module) 에서 터미널 출력을 제어할 때, 또는 디버깅 (Debugging) 도구 개발 시 ANSI 코드를 직접 사용할 기회가 많습니다. 이 문서는 모든 ANSI 코드를 체계적으로 정리한 완전 레퍼런스입니다.

역사 및 표준

ANSI 이스케이프 시퀀스의 역사는 1970 년대 초기 비디오 터미널로 거슬러 올라갑니다.

연혁

주요 표준 문서

• ANSI X3.64-1979 — 최초 ANSI 표준 (현재 폐기)
• ECMA-48 — European Computer Manufacturers Association 표준 (현재 유지보수)
• ISO/IEC 6429:1992 — 국제 표준, ECMA-48 과 동일
• VT100 User Guide — DEC 공식 매뉴얼, 역사적 참고
• xterm Control Sequences — 현대 xterm 의 확장 시퀀스 문서

ANSI 시퀀스 구조

모든 ANSI 이스케이프 시퀀스는 다음 구조를 따릅니다:

ESC [ Param1 ; Param2 ; ... ; ParamN Command

• ESC (0x1B) — 이스케이프 문자. 모든 제어 시퀀스의 시작
• [ (0x5B) — CSI(Control Sequence Introducer). CSI 시퀀스 시작을 알림
• Param — 10 진수 파라미터. 여러 개는 세미콜론 (;) 으로 구분
• Command — 최종 바이트. 실행할 명령을 지정 (대문자 알파벳)

파라미터 규칙

• 파라미터 생략 시 기본값 사용 (대부분 0 또는 1)
• ESC[m 은 ESC[0m 과 동일 (속성 리셋)
• ESC[H 는 ESC[0;0H 와 동일 (커서 홈 위치)
• 허용되지 않는 파라미터는 무시되거나 기본 동작 수행

C0 제어 문자 (0x00 ~ 0x1F)

ANSI 이스케이프보다 먼저 정의된 ASCII C0 영역의 제어 문자입니다. ECMA-48 기반의 모든 터미널이 공통으로 인식합니다. ANSI 시퀀스의 시작인 ESC (0x1B) 도 여기 속합니다.

C1 제어 문자 (0x80 ~ 0x9F) 와 7 비트 등가

ECMA-48 은 8 비트 환경의 C1 영역에도 제어 문자를 정의합니다. 7 비트 환경 (UTF-8 포함) 에서는 ESC + 알파벳으로 등가 표현합니다. UTF-8 환경에서는 7 비트 형식을 사용해야 안전합니다 (8 비트 형식은 다바이트 문자와 충돌).

ESC 단독 시퀀스 (CSI 가 아닌)

ESC 다음에 [ 가 아닌 다른 문자가 오는 경우입니다. VT100 시대부터 정의된 핵심 시퀀스가 많습니다.

표준 분류 및 출처 표기 규약

이 문서의 모든 시퀀스 표는 "표준" 컬럼으로 출처를 명시합니다. 같은 시퀀스라도 표준에 따라 동작이 다를 수 있으므로, 어느 표준을 따르는지 알아야 합니다.

표준의 계보

표준 간 동작 분기 (함정)

같은 시퀀스가 표준·터미널마다 다른 동작을 하거나, 한쪽에는 정의되지 않은 경우입니다. 크로스 플랫폼 (Cross-Platform) 도구를 만들 때 가장 주의해야 할 포인트입니다.

SGR 속성 — 같은 번호 다른 의미

커서 위치 저장/복원 — 두 가지 방식 공존

화면 지우기 — 표준 외 확장

256 색·RGB 인자 구분자 — 세미콜론 vs 콜론

이는 ECMA-48 표준 해석의 핵심 함정 중 하나입니다.

OSC 종결자 — BEL vs ST

대체 화면 버퍼 — ?47 / ?1047 / ?1049 차이

커서 이동 및 제어

커서 관련 시퀀스는 터미널에서 커서 위치를 이동하거나 숨기는 데 사용합니다.

커서 위치 이동

커서 이동 시각화

각 커서 이동 명령이 실제 화면에서 어떤 방향과 거리만큼 움직이는지 좌표 격자 위에 표현했습니다.

커서 모양 및 가시성

고급 커서 제어 (DEC 확장)

DEC 터미널에서 도입된 확장 시퀀스로, 현대 에뮬레이터에서도 널리 지원됩니다.

// 커서 위치 저장 → 이동 → 복원 예제
void save_restore_cursor_example(void)
{
    // 커서 현재 위치 저장
    printk("\033[s");
    
    // 임의 위치로 이동하여 작업
    printk("\033[20;10H");
    printk("임시 메시지 출력");
    
    // 저장된 위치로 복원
    printk("\033[u");
    printk("원래 위치로 돌아옴");
}

// 대체 화면 버퍼 사용 (풀스크린 앱용)
void use_alternate_screen(void)
{
    // 대체 버퍼로 전환 + 화면 지우기
    printf("\033[?1049h\033[2J\033[H");
    
    // ... 풀스크린 작업 수행 ...
    
    // 원본 버퍼로 복원
    printf("\033[?1049l");
}

// 커서 숨기기 → 작업 수행 → 커서 표시 예제
void hide_cursor_do_work_show(void)
{
    printk("\033[?25l");  // 커서 숨김
    
    // ... 시간 소요 작업 ...
    
    printk("\033[?25h");  // 커서 다시 표시
}

색상 및 텍스트 속성

ANSI 색상은 3 단계로 진화했습니다: 기본 8 색 → 256 색 → 24 비트 RGB.

기본 8 색 (Standard Colors)

표준: ECMA-48 (전경 30~37, 배경 40~47) — 모든 터미널 공통 / aixterm 기원, xterm 표준화 (밝은 전경 90~97, 밝은 배경 100~107).

16 색 팔레트 시각화

아래 SVG 는 표준 8 색 (30~37) 과 밝은 8 색 (90~97) 이 실제로 어떻게 표시되는지 보여줍니다.

텍스트 속성 (SGR — Select Graphic Rendition)

텍스트 속성 시각화

각 SGR 속성이 실제 터미널에서 어떻게 보이는지 비교한 그림입니다.

SGR 확장 속성 (Extended SGR)

ECMA-48 표준 외에 xterm·kitty 등이 추가로 정의한 SGR 시퀀스입니다.

// 확장 속성 활용: 밑줄 색상 변경
void print_with_underline_color(const char *text)
{
    // 빨간색 밑줄 + 파란색 텍스트
    printk("\033[4m");         // 밑줄 활성화
    printk("\033[58;5;196m");  // 밑줄 색상: 빨강 (256 색)
    printk("\033[38;5;21m");   // 텍스트 색상: 파랑
    printk("%s", text);
    printk("\033[0m");         // 모든 속성 리셋
}

// RGB 밑줄 색상
void print_rainbow_underline(const char *text)
{
    printk("\033[4m");              // 밑줄
    printk("\033[58;2;255;0;0m");   // 빨간 밑줄 (RGB)
    printk("\033[38;2;0;128;255m"); // 파란 텍스트
    printk("%s", text);
    printk("\033[0m");
}

256 색 모드

xterm-256color 에서 지원하는 256 색은 다음 구조로 구성됩니다:

• 0-15: 기본 16 색 (8 색 + 밝은 8 색)
• 16-231: 6×6×6 RGB 컬러 큐브 (각 채널 6 단계: 0, 95, 135, 175, 215, 255)
• 232-255: 회색조 (Grayscale) 24 단계

# 256 색 전경색
echo -e "\033[38;5;196m빨간색\033[0m"   # 196 번: 밝은 빨강
echo -e "\033[38;5;21m파란색\033[0m"    # 21 번: 밝은 파랑
echo -e "\033[38;5;232m회색\033[0m"     # 232 번: 어두운 회색

# 256 색 배경색
echo -e "\033[48;5;226m노란 배경\033[0m"  # 226 번: 밝은 노랑

// 커널에서 256 색 사용 예제
void print_colored_message(const char *msg)
{
    // 256 색 전경색 (빨강)
    printk("\033[38;5;196m");
    printk("ERROR: %s", msg);
    printk("\033[0m");  // 속성 리셋
}

24 비트 RGB 트루컬러

최신 터미널은 1600 만 색 (2^24) 을 지원합니다.

# RGB 전경색: R;G;B (각 0-255)
echo -e "\033[38;2;255;128;0m주황색\033[0m"

# RGB 배경색
echo -e "\033[48;2;64;64;128m남색 배경\033[0m"

// RGB 컬러 직접 지정
#define COLOR_RGB(r,g,b) "\033[38;2;" XSTRING(r) ";" XSTRING(g) ";" XSTRING(b) "m"

// 사용 예
printk(COLOR_RGB(255, 128, 64) "커스텀 색상\033[0m");

256 색 컬러 큐브 시각화

256 색의 16-231 번은 6×6×6 RGB 큐브를 형성합니다. 각 채널은 6 단계 (0, 95, 135, 175, 215, 255) 로 양자화됩니다.

# 256 색 컬러 큐브 출력 (6x6x6)
for green in 0 1 2 3 4 5; do
    for red in 0 1 2 3 4 5; do
        for blue in 0 1 2 3 4 5; do
            color=$((16 + red*36 + green*6 + blue))
            printf "\033[48;5;%dm   " $color
        done
        printf "\033[0m "
    done
    printf "\\n"
done

# 회색조 (232-255) 출력
for gray in {232..255}; do
    printf "\033[48;5;%dm   " $gray
done
printf "\033[0m\\n"

256 색 구조 시각화

256 색의 0-15, 16-231 (6×6×6 큐브), 232-255 (회색조) 영역을 SVG 로 한눈에 보여줍니다.

OSC 시퀀스 (Operating System Command)

OSC 시퀀스는 터미널 제목·링크·클립보드 등 운영체제 연동 기능을 제공합니다. 형식: ESC] Ps ; Pt ST — 여기서 Ps 는 OSC 번호, Pt 는 데이터, ST 는 종결자 (BEL=0x07 또는 ESC \\).

# 터미널 제목 설정 (bash 프롬프트용)
set_title() {
    printf "\033]0;%s@%s:%s\007" "$USER" "$HOSTNAME" "$PWD"
}

# 하이퍼링크 출력 (최신 터미널)
print_link() {
    local url="$1"
    local text="$2"
    printf "\033]8;;%s\007%s\033]8;;\007" "$url" "$text"
}

# Shell Integration (iTerm2)
prompt_start() {
    printf "\033]133;A\007"  # 프롬프트 시작
}

command_start() {
    printf "\033]133;B\007"  # 명령 실행 시작
}

command_end() {
    printf "\033]133;D;%d\007" $?  # 명령 종료 + 종료코드
}

화면 지우기 및 스크롤

※ 더 자세한 행/문자 단위 조작은 삽입·삭제·스크롤 영역 시퀀스 절 참조.

# 화면 전체 지우기 + 커서 홈
clear_screen() {
    printf "\033[2J\033[H"
}

# 현재 행 지우기 + 메시지 출력 (프롬프트용)
update_line() {
    printf "\033[2K\r"  // 행 전체 지우기 + 행 시작
    printf "처리 중... %d%%" $1
}

지우기 영역 시각화

각 지우기 명령 (ED, EL) 이 화면에서 어떤 부분을 지우는지 표시합니다. 회색 영역이 지워지는 부분, 청색 점이 커서 위치입니다.

삽입·삭제·스크롤 영역 시퀀스

커서 위치를 기준으로 글자나 행을 삽입·삭제하거나, 스크롤 영역 (Scroll Region) 을 지정하는 시퀀스입니다. 화면 일부만 갱신하는 TUI (Text User Interface) 프로그램의 핵심입니다.

DECSET / DECRST private 모드 종합표

ESC[? 로 시작하는 private mode 시퀀스 (? = DEC private parameter). h=설정, l=해제. 본문 곳곳에 흩어진 모드를 한자리에 모았습니다.

마우스 트래킹 — 인코딩 비교

모드(?1000·?1002 등)와 인코딩(?1006 등)을 함께 켜야 합니다. 인코딩별로 좌표 표현이 크게 다릅니다.

# 마우스 트래킹 활성화 (현대 권장 조합)
printf "\033[?1002h\033[?1006h"  # 드래그 보고 + SGR 인코딩

# 비활성화 (반드시 종료 시 호출)
printf "\033[?1002l\033[?1006l"

# 응답 예: 좌클릭 (10,5) 누름 → ESC[<0;10;5M
#         좌클릭 (10,5) 놓음 → ESC[<0;10;5m

DCS·DA·DSR — 장치 제어 / 식별 / 상태 보고

DCS (Device Control String, ESC P ... ST)

DA — Device Attributes (장치 식별)

DSR — Device Status Report (상태 보고)

ESC[t — 윈도우 조작 (xterm 확장)

ESC[nt 또는 ESC[n;a;bt 형태. xterm 이 정의한 다양한 윈도우 조작 시퀀스로, 보안상 일부는 비활성화되어 있는 경우가 많습니다.

함수 키 / 특수 키 입력 시퀀스

지금까지의 시퀀스는 모두 프로그램 → 터미널 (출력 방향) 이었습니다. 반대로 사용자가 키를 누르면 터미널 → 프로그램 으로 시퀀스가 전송됩니다. 이 표는 cat · sed -n l 등으로 확인할 수 있습니다.

Modifier (Shift/Ctrl/Alt) 조합 — xterm 형식

xterm 은 modifier 조합을 시퀀스 안에 추가 인자로 인코딩합니다. ESC[1;mA 형식 — m 은 1+modifier 비트마스크.

실전 활용 예제

커널 로그 색상 출력

// 디버그 메시지 색상 구분
#define LOG_ERROR(fmt, ...) \
    printk("\033[38;5;196m[ERROR]\033[0m " fmt, ##__VA_ARGS__)

#define LOG_WARN(fmt, ...) \
    printk("\033[38;5;214m[WARN]\033[0m " fmt, ##__VA_ARGS__)

#define LOG_INFO(fmt, ...) \
    printk("\033[38;5;45m[INFO]\033[0m " fmt, ##__VA_ARGS__)

#define LOG_DEBUG(fmt, ...) \
    printk("\033[38;5;245m[DEBUG]\033[0m " fmt, ##__VA_ARGS__)

// 사용 예
LOG_ERROR("DMA 매핑 실패: %d\\n", err);
LOG_INFO("모듈 로드 완료\\n");

프로그레스 바 (진행 표시줄)

// 단일 행 업데이트 프로그레스 바
void show_progress(int percent)
{
    int i;
    int filled = percent / 5;  // 20 단계
    
    printk("\033[2K\r");  // 행 지우기 + 행 시작
    printk("[");
    
    for (i = 0; i < 20; i++) {
        if (i < filled)
            printk("\033[38;5;46m█\033[0m");  // 녹색
        else
            printk("░");
    }
    
    printk("] %3d%%", percent);
}

상태 테이블 출력

// 상태 표시용 컬러 테이블
const char *status_color(int status)
{
    switch (status) {
    case 0:  return "\033[38;5;46m";   // 성공: 초록
    case -1: return "\033[38;5;196m";  // 실패: 빨강
    case -2: return "\033[38;5;214m";  // 경고: 주황
    default: return "\033[0m";         // 기본
    }
}

// 사용 예
printk("%s%-20s\033[0m  %s\\n",
       status_color(ret),
       "device_name",
       (ret == 0) ? "OK" : "FAIL");

터미널 초기화 및 복원

# 터미널 완전 초기화 (스크립트 시작 시)
init_terminal() {
    # 화면 지우기
    printf "\033[2J\033[3J"
    # 커서 홈
    printf "\033[H"
    # 스크롤백 버퍼 (Buffer) 삭제
    printf "\033[3J"
}

# 원본 터미널 상태 복원 (스크립트 종료 시)
restore_terminal() {
    # 모든 속성 리셋
    printf "\033[0m"
    # 커서 표시
    printf "\033[?25h"
    # 기본 색상 복원
    printf "\033[39;49m"
}

실전 패턴 1 — 컬러 로그 레벨 출력

가장 흔한 패턴입니다. 로그 레벨별로 색상과 라벨을 다르게 출력해 가독성을 높입니다.

# 색상 변수 선언 (NO_COLOR 환경 변수 존중)
if [ -z "$NO_COLOR" ] && [ -t 1 ]; then
    RED="\033[1;31m"; YEL="\033[1;33m"; GRN="\033[1;32m"
    BLU="\033[1;34m"; DIM="\033[2;37m"; RST="\033[0m"
else
    RED=""; YEL=""; GRN=""; BLU=""; DIM=""; RST=""
fi

log_error() { printf "${RED}[ERROR]${RST} %s\n" "$*"; }
log_warn()  { printf "${YEL}[WARN ]${RST} %s\n" "$*"; }
log_info()  { printf "${GRN}[INFO ]${RST} %s\n" "$*"; }
log_debug() { printf "${DIM}[DEBUG]${RST} %s\n" "$*"; }

실전 패턴 2 — 진행 표시 스피너

오래 걸리는 작업 중 사용자에게 “살아있음” 을 알리는 스피너입니다. \r + \033[2K 조합으로 같은 행을 계속 갱신합니다.

# 백그라운드 작업과 함께 회전 스피너 출력
spinner() {
    local pid=$1
    local frames='⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏'
    local i=0
    printf "\033[?25l"  # 커서 숨김
    while kill -0 $pid 2>/dev/null; do
        local ch=${frames:$((i%10)):1}
        printf "\r\033[36m%s\033[0m 작업 중..." "$ch"
        i=$((i+1))
        sleep 0.1
    done
    printf "\r\033[2K\033[32m✓\033[0m 완료\n"
    printf "\033[?25h"  # 커서 복원
}

# 사용 예: 긴 작업을 백그라운드로 실행
long_task &
spinner $!

실전 패턴 3 — 다단계 프로그레스 바

여러 작업의 진행률을 한 번에 보여주는 다단계 프로그레스 바입니다. ESC[s / ESC[u 로 위치 저장 후 ESC[n;1H 로 절대 이동합니다.

draw_bar() {
    local name="$1"; local percent=$2; local width=30
    local filled=$((percent * width / 100))
    local empty=$((width - filled))
    printf "%-12s [" "$name"
    printf "\033[42m%*s\033[0m" $filled ""          # 채움 (녹색)
    printf "\033[100m%*s\033[0m" $empty ""         # 빈 칸 (회색)
    printf "] %3d%%\n" $percent
}

show_dashboard() {
    printf "\033[?25l\033[2J\033[H"
    while :; do
        printf "\033[H\033[1;36m=== 빌드 진행 상황 ===\033[0m\n\n"
        draw_bar "컴파일"   $compile_pct
        draw_bar "링크"     $link_pct
        draw_bar "테스트"   $test_pct
        draw_bar "패키징"   $pack_pct
        [ $pack_pct -ge 100 ] && break
        sleep 0.5
    done
    printf "\033[?25h"
}

실전 패턴 4 — 색상 박스 (Banner / Alert)

경계 문자(┌─┐│└─┘)와 배경색을 조합한 시각적 알림 박스입니다. CLI 도구의 "환영 메시지"·"경고 알림"에 자주 쓰입니다.

# 박스 그리기 (제목 + 본문)
box() {
    local color="$1"; local title="$2"; local body="$3"
    local width=60
    printf "\033[%sm┌" "$color"
    printf "─%.0s" $(seq 1 $((width-2)))
    printf "┐\033[0m\n"
    printf "\033[%sm│\033[1m %-*s\033[0m\033[%sm│\033[0m\n" \
           "$color" $((width-3)) "$title" "$color"
    printf "\033[%sm├%.0s─├\033[0m\n" "$color" $(seq 1 $((width-2)))
    printf "\033[%sm│\033[0m %-*s \033[%sm│\033[0m\n" \
           "$color" $((width-4)) "$body" "$color"
    printf "\033[%sm└%.0s─└\033[0m\n" "$color" $(seq 1 $((width-2)))
}

box "31" "⚠ 위험"     "디스크 사용량 95% 초과"
box "33" "⚡ 경고"     "메모리 부족 — swap 활성"
box "32" "✓ 성공"     "빌드 완료 (3m 14s)"

실전 패턴 5 — Diff 스타일 출력

git diff·diff -u 출력 스타일을 직접 흉내낼 때 쓰는 패턴입니다.

color_diff() {
    while IFS= read -r line; do
        case "$line" in
            +++*|---*) printf "\033[1;36m%s\033[0m\n" "$line" ;;  # 헤더: 청록
            @@*)       printf "\033[1;35m%s\033[0m\n" "$line" ;;  # 헝크: 자주
            +*)        printf "\033[32m%s\033[0m\n" "$line"   ;;  # 추가: 녹색
            -*)        printf "\033[31m%s\033[0m\n" "$line"   ;;  # 삭제: 빨강
            *)         printf "%s\n" "$line"                 ;;  # 그대로
        esac
    done
}

diff -u old.c new.c | color_diff

실전 패턴 6 — 테이블 헤더 + 행 컬러링

모니터링 도구 (htop, btop) 처럼 헤더는 반전, 행은 상태별 색을 지정합니다.

# 헤더: 흰 배경 + 검정 글자 + 굵게
printf "\033[7;1m %-5s %-15s %-8s %-10s \033[0m\n" "PID" "COMMAND" "CPU%%" "STATE"

# 데이터 행: STATE 별로 색 지정
print_row() {
    local pid=$1 cmd=$2 cpu=$3 state=$4
    case $state in
        R) color="\033[32m" ;;  # Running: 녹색
        S) color="\033[36m" ;;  # Sleeping: 청록
        D) color="\033[33m" ;;  # Disk wait: 노랑
        Z) color="\033[31m" ;;  # Zombie: 빨강
        *) color=""          ;;
    esac
    printf "%b %-5s %-15s %-8s %-10s\033[0m\n" \
           "$color" "$pid" "$cmd" "$cpu" "$state"
}

실전 패턴 7 — 그라데이션 / 무지개 텍스트

RGB 트루컬러로 글자마다 색을 바꿔 그라데이션 효과를 냅니다. 환영 배너·축하 메시지에 자주 쓰입니다.

rainbow() {
    local text="$1"
    local n=${#text}
    local i=0
    while [ $i -lt $n ]; do
        # HSV → RGB 의 단순화: i/n 을 hue 로 사용
        local hue=$((i * 360 / n))
        local r g b
        case $((hue / 60)) in
            0) r=255; g=$((hue%60 * 255/60)); b=0   ;;
            1) r=$((255-(hue%60)*255/60)); g=255; b=0   ;;
            2) r=0; g=255; b=$((hue%60 * 255/60)) ;;
            3) r=0; g=$((255-(hue%60)*255/60)); b=255 ;;
            4) r=$((hue%60 * 255/60)); g=0; b=255 ;;
            5) r=255; g=0; b=$((255-(hue%60)*255/60)) ;;
        esac
        printf "\033[38;2;%d;%d;%dm%s" $r $g $b "${text:$i:1}"
        i=$((i+1))
    done
    printf "\033[0m\n"
}

rainbow "Hello, Linux Kernel!"

실전 패턴 8 — 라이브 카운트다운 / 재진입 갱신

카운트다운, 시계, 실시간 (Real-time) 통계 등 같은 위치를 계속 갱신하는 패턴입니다.

countdown() {
    local sec=$1
    printf "\033[?25l"  # 커서 숨김
    while [ $sec -gt 0 ]; do
        local color="32"          # 녹색 (안전)
        [ $sec -le 10 ] && color="33"  # 노랑 (주의)
        [ $sec -le 3 ]  && color="31"  # 빨강 (긴박)
        printf "\r\033[2K남은 시간: \033[1;%sm%2d초\033[0m" "$color" $sec
        sleep 1
        sec=$((sec-1))
    done
    printf "\r\033[2K\033[1;31m⏰ 시간 종료!\033[0m\n"
    printf "\033[?25h"
}

countdown 10

실전 패턴 9 — 트리 / 디렉터리 출력

tree 명령처럼 박스 그리기 문자(├ └ │)와 색상으로 계층을 표현합니다.

# 디렉터리: 청색·굵게,  실행 파일: 녹색,  심볼릭 링크: 청록
colorize_name() {
    local path="$1"
    if [ -d "$path" ]; then
        printf "\033[1;34m%s/\033[0m" "$(basename "$path")"
    elif [ -L "$path" ]; then
        printf "\033[1;36m%s\033[0m -> %s" "$(basename "$path")" "$(readlink "$path")"
    elif [ -x "$path" ]; then
        printf "\033[1;32m%s*\033[0m" "$(basename "$path")"
    else
        printf "%s" "$(basename "$path")"
    fi
}

실전 패턴 10 — 클릭 가능한 하이퍼링크 (OSC 8)

최신 터미널 (GNOME Terminal, iTerm2, Windows Terminal) 은 OSC 8 시퀀스로 클릭 가능한 링크를 지원합니다.

# 형식: \033]8;;URL\033\\ 표시텍스트 \033]8;;\033\\
link() {
    local url="$1" text="$2"
    printf "\033]8;;%s\033\\\033[4;34m%s\033[0m\033]8;;\033\\" "$url" "$text"
}

# 사용 예: 에러 메시지에 문서 링크 첨부
printf "\033[31mERROR:\033[0m parse failed — see "
link "https://example.com/docs/parser" "문서"
printf "\n"

리눅스 커널 구현

리눅스 커널은 drivers/tty/vt/vt.c 에서 ANSI 이스케이프 시퀀스를 파싱합니다. 주요 함수는 다음과 같습니다:

• do_con_write() — 콘솔 출력 진입점 (Entry Point)
• parse_escape_sequence() — ESC 시퀀스 파싱
• set_cursor_position() — 커서 이동 처리
• set_color() — SGR 색상 속성 적용

// drivers/tty/vt/vt.c 간략화 예제
static void do_con_write(struct vc_data *vc, const unsigned char *buf, int count)
{
    const unsigned char *p = buf;
    int i;
    
    for (i = 0; i < count; i++) {
        switch (vc->vc_state) {
        case ESnormal:
            if (*p == '\033') {
                vc->vc_state = ESescape;
            } else {
                // 일반 문자 출력
                do_con_putc(vc, *p);
            }
            break;
            
        case ESescape:
            if (*p == '[') {
                vc->vc_state = ESsquare;
                vc->vc_par[0] = 0;
                vc->vc_npar = 0;
            }
            break;
            
        case ESsquare:
            if (*p >= '0' && *p <= '9') {
                // 파라미터 누적
                vc->vc_par[vc->vc_npar] *= 10;
                vc->vc_par[vc->vc_npar] += *p - '0';
            } else if (*p == ';') {
                vc->vc_npar++;
            } else {
                // 명령 실행
                execute_control(vc, *p);
                vc->vc_state = ESnormal;
            }
            break;
        }
        p++;
    }
}

커널 파싱 상태 머신

리눅스 커널은 상태 머신을 사용하여 ANSI 시퀀스를 파싱합니다. 각 상태는 다음과 같습니다:

SGR 색상 처리 (커널 내부)

// drivers/tty/vt/vt.c — SGR 색상 처리 간략화
static void set_color(struct vc_data *vc, int attr, int *sep)
{
    switch (attr) {
    case 0:  // 기본값으로 리셋
        vc->vc_def_color = 0x07;  // 흰색/검정
        vc->vc_underline = 0;
        vc->vc_reverse = 0;
        break;
        
    case 1:  // 굵게 (Bold)
        vc->vc_bold = 1;
        break;
        
    case 4:  // 밑줄 (Underline)
        vc->vc_underline = 1;
        break;
        
    case 7:  // 반전 (Reverse)
        vc->vc_reverse = 1;
        break;
        
    case 30 ... 37:  // 전경색 (Foreground)
        vc->vc_fgcolor = attr - 30;
        break;
        
    case 40 ... 47:  // 배경색 (Background)
        vc->vc_bkcolor = attr - 40;
        break;
        
    case 39:  // 기본 전경색 복원
        vc->vc_fgcolor = 7;
        break;
        
    case 49:  // 기본 배경색 복원
        vc->vc_bkcolor = 0;
        break;
    }
}

호환성 및 지원 여부

모든 터미널이 모든 ANSI 코드를 지원하는 것은 아닙니다. 다음 명령으로 지원 기능을 확인하세요:

# 터미널 종류 확인
echo $TERM

# 컬러 지원 확인 (tput 사용)
tput colors    # 8, 16, 256, 또는 16777216

# 터미널 기능 테스트
infocmp        # terminfo 덤프

tmux/screen 특수 고려사항

터미널 멀티플렉서 (tmux, screen) 는 ANSI 시퀀스를 추가로 처리하거나 제한합니다.

tmux

• 대체 화면 버퍼: tmux 는 자체 버퍼를 사용하므로 ESC[?1049h 가 비활성화될 수 있음
• 색상 제한: default-terminal 설정에 따라 256 색/RGB 지원 여부 결정
• 패스스루 시퀀스: tmux 는 일부 시퀀스를 외부 터미널로 전달하지 않음

# .tmux.conf — 256 색/RGB 활성화
set -g default-terminal "screen-256color"

# RGB 트루컬러 활성화 (tmux 3.0+)
set -ga terminal-overrides ",*256col:Tc"

# 브레이스티드 페이스트 비활성화 (일부 문제 발생 시)
set -gq terminal-features ",*:clipboard:off"

GNU screen

• capa 기능: screen 은 ANSI 시퀀스를 캡처하여 자체 버퍼에 저장
• 하드웨어 제한: screen 세션 내부에서는 256 색만 지원 (RGB 불가)
• 터미널 타입: TERM=screen-256color 권장

# .screenrc — 256 색 활성화
termcapinfo xterm* is@:ks@:ke@
setenv "TERM" "screen-256color"

# screen 세션에서 외부 터미널 기능 확인
echo $TMUX   # tmux 내부인지 확인
echo $STY    # screen 세션 ID

보안 고려사항 (ANSI 인젝션)

ANSI 이스케이프 시퀀스는 터미널 인젝션 공격에 악용될 수 있습니다. 신뢰할 수 없는 데이터를 출력할 때는 주의가 필요합니다.

주요 공격 벡터

방어 기법

// 신뢰할 수 없는 출력에서 ANSI 시퀀스 제거
static char *strip_ansi_sequences(const char *input)
{
    const char *p = input;
    char *out, *buf;
    int in_escape = 0;
    
    buf = kmalloc(strlen(input) + 1, GFP_KERNEL);
    if (!buf)
        return NULL;
    
    out = buf;
    while (*p) {
        if (*p == '\033') {
            in_escape = 1;
        } else if (in_escape) {
            if ((*p >= 'A' && *p <= 'Z') ||
                (*p >= 'a' && *p <= 'z') ||
                *p == '@' || *p == '\\') {
                in_escape = 0;  // 시퀀스 종료
            }
            // ESC 시퀀스는 출력에서 제외
        } else {
            *out++ = *p;  // 일반 문자만 복사
        }
        p++;
    }
    *out = '\0';
    return buf;
}

// 사용 예: 로그 출력 전 필터링
void safe_printk(const char *fmt, ...)
{
    char *buf, *safe_buf;
    // ... 포맷팅 ...
    
    safe_buf = strip_ansi_sequences(buf);
    if (safe_buf) {
        printk("%s", safe_buf);
        kfree(safe_buf);
    }
    kfree(buf);
}

# Bash 에서 ANSI 시퀀스 제거 (sed 사용)
strip_ansi() {
    sed -r 's/\x1B\[[0-9;]*[a-zA-Z]//g'
}

# 사용 예
echo -e "\033[31m빨간색\033[0m" | strip_ansi
# 출력: "빨간색" (색상 코드 제거됨)

# 보안 설정: 클립보드 조작 방지
printf "\033[?52l"  # 클립보드 조작 비활성화 (지원 터미널)

빠른 참조 카드

자주 사용하는 ANSI 코드만 모친 치트시트입니다.

# ===== 기본 =====
echo -e "\033[0m"     # 모든 속성 리셋 (가장 중요!)
echo -e "\033[H"     # 커서 홈
echo -e "\033[2J"    # 화면 전체 지우기

# ===== 색상 =====
echo -e "\033[31m"    # 빨간 전경색
echo -e "\033[42m"    # 녹색 배경색
echo -e "\033[1m"     # 굵게
echo -e "\033[4m"     # 밑줄

# ===== 256 색 =====
echo -e "\033[38;5;196m"  # 256 색 전경
echo -e "\033[48;5;21m"   # 256 색 배경

# ===== RGB =====
echo -e "\033[38;2;R;G;Bm"  # RGB 전경
echo -e "\033[48;2;R;G;Bm"  # RGB 배경

# ===== 커서 =====
echo -e "\033[?25l"    # 커서 숨김
echo -e "\033[?25h"    # 커서 표시
echo -e "\033[10;20H"  # 10 행 20 열로 이동

# ===== 행 제어 =====
echo -e "\033[2K\r"    # 행 지우기 + 행 시작 (프롬프트용)

참고자료

• 표준 문서
  • ECMA-48: Control Functions for Coded Character Sets — 국제 표준
  • Wikipedia — ANSI escape code — 종합 개요
• 터미널 에뮬레이터 문서
  • VT100.net — VT510 Reference Manual — 역사적 레퍼런스
  • xterm Control Sequences — 현대 표준
  • iTerm2 Escape Codes — macOS 고급 기능
  • Windows Console Virtual Terminal Sequences — Windows 10+ 지원
• 리눅스 커널
  • Linux console_codes(4) man page — 커널 콘솔 구현
  • Linux Kernel vt.c Source — 실제 파싱 코드
• 라이브러리 및 도구
  • Terminal Colors Specification (GitHub) — 색상 지원 감지
  • NO_COLOR.org — 색상 비활성화 표준
  • CLICOLOR — 색상 지원 환경 변수
• 보안
  • ANSI Escape Sequence Injection Vulnerabilities — 보안 연구
  • Snyk — ANSI Escape Sequence Vulnerabilities — 실제 사례

관련 라이브러리

ANSI 코드를 직접 다루지 않고도 색상을 활용할 수 있는 라이브러리들입니다.

# tput 사용 예 (추천: 크로스플랫폼 호환)
tput setaf 1   # 빨간 전경색
echo "Error message"
tput sgr0      # 속성 리셋

# terminfo 확인
infocmp        # 현재 터미널 기능 덤프
tic -x         # terminfo 컴파일

# Python colorama 사용 예
from colorama import Fore, Back, Style, init

init()  # Windows 호환성 초기화

print(Fore.RED + "Error: " + Style.RESET_ALL + "Something failed")
print(Back.GREEN + Fore.WHITE + " Success " + Style.RESET_ALL)

# 256 색
print(f"\033[38;5;196mBright Red\033[0m")

if [ -z "$NO_COLOR" ]; then
    RED="\033[31m"
    NC="\033[0m"
else
    RED=""
    NC=""
fi

용어 정리

ANSI (American National Standards Institute)

미국 국가 표준 협회. ANSI X3.64 는 터미널 제어 코드 표준.

CSI (Control Sequence Introducer)

ESC[ (0x1B 0x5B). 파라미터를 받는 제어 시퀀스의 시작.

SGR (Select Graphic Rendition)

ESC[...m 시퀀스. 색상, 굵기, 밑줄 등 텍스트 속성 설정.

DEC

Digital Equipment Corporation. VT100 터미널 제조사. 많은 확장 시퀀스 제안.

VT100

1978 년 DEC 에서 출시한 비디오 터미널. 현대 ANSI 의 기반.

xterm

X Window System 용 터미널 에뮬레이터. 가장 널리 사용되는 레퍼런스 구현.

트루컬러 (Truecolor)

24 비트 RGB 색상 (1600 만 색). ESC[38;2;R;G;Bm 시퀀스 사용.

브레이스티드 페이스트 (Bracketed Paste)

붙여넣기 시 ESC[200~ / ESC[201~ 로 감싸서 명령 인젝션 방지.

OSC (Operating System Command)

ESC]param;data BEL. 터미널 제목, 링크 등 OS 연동 기능.

terminfo / termcap

터미널 기능 데이터베이스. tput 명령이 이를 사용.