ELF (Executable and Linkable Format)

ELF(Executable and Linkable Format)는 System V ABI에서 정의한 바이너리 형식으로, Linux에서 실행 파일, 공유 라이브러리, 오브젝트 파일, 코어 덤프의 표준 형식입니다. 이 문서는 ELF 포맷의 전체 구조(헤더, 세그먼트, 섹션, 심볼 테이블, 재배치, 동적 링킹, GOT/PLT), exec() 실행 흐름, Auxiliary Vector, ASLR/PIE, vDSO, TLS(Thread-Local Storage), 코어 덤프, 커널 모듈(.ko) ELF 구조, binfmt 핸들러, 심볼 버저닝, 스택 언와인딩(.eh_frame/DWARF/ORC), 링커 스크립트, ELF 보안 강화 기법을 다룹니다.

ELF 포맷 개요 (ELF Format Overview)

ELF는 System V ABI에서 정의한 바이너리 형식으로, 실행 파일, 공유 라이브러리, 오브젝트 파일, 코어 덤프를 모두 표현합니다. ELF 파일은 크게 세 부분으로 구성됩니다:

ELF 파일의 유형은 e_type 필드로 구분됩니다:

ELF 헤더 (ELF Header)

모든 ELF 파일은 파일 오프셋 0에서 시작하는 ELF 헤더를 가집니다. 이 헤더는 파일의 전체적인 속성과 나머지 헤더 테이블의 위치를 지정합니다.

/* include/uapi/linux/elf.h */
typedef struct elf64_hdr {
    unsigned char  e_ident[EI_NIDENT]; /* ELF 식별자 (16바이트) */
    Elf64_Half     e_type;       /* 파일 타입: ET_EXEC, ET_DYN 등 */
    Elf64_Half     e_machine;    /* 아키텍처: EM_X86_64, EM_AARCH64 등 */
    Elf64_Word     e_version;    /* ELF 버전 (항상 EV_CURRENT = 1) */
    Elf64_Addr     e_entry;      /* 엔트리 포인트 가상 주소 */
    Elf64_Off      e_phoff;      /* 프로그램 헤더 테이블의 파일 오프셋 */
    Elf64_Off      e_shoff;      /* 섹션 헤더 테이블의 파일 오프셋 */
    Elf64_Word     e_flags;      /* 프로세서별 플래그 */
    Elf64_Half     e_ehsize;     /* ELF 헤더 크기 (64바이트) */
    Elf64_Half     e_phentsize;  /* 프로그램 헤더 엔트리 크기 */
    Elf64_Half     e_phnum;      /* 프로그램 헤더 엔트리 수 */
    Elf64_Half     e_shentsize;  /* 섹션 헤더 엔트리 크기 */
    Elf64_Half     e_shnum;      /* 섹션 헤더 엔트리 수 */
    Elf64_Half     e_shstrndx;   /* 섹션 이름 문자열 테이블 인덱스 */
} Elf64_Ehdr;

e_ident 배열(16바이트)은 ELF 파일을 식별하는 매직 넘버와 기본 속성을 담고 있습니다:

# readelf로 ELF 헤더 확인
$ readelf -h /bin/ls
ELF Header:
  Magic:   7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00
  Class:                             ELF64
  Data:                              2's complement, little endian
  Version:                           1 (current)
  OS/ABI:                            UNIX - System V
  Type:                              DYN (Position-Independent Executable file)
  Machine:                           Advanced Micro Devices X86-64
  Entry point address:               0x6b10
  Start of program headers:          64 (bytes into file)
  Start of section headers:          140224 (bytes into file)
  Number of program headers:         13
  Number of section headers:         31

프로그램 헤더 — 세그먼트 (Program Headers)

프로그램 헤더 테이블은 커널이 프로세스 이미지를 생성할 때 사용하는 세그먼트(segment) 정보를 담고 있습니다. 커널의 load_elf_binary()는 이 테이블을 순회하면서 각 세그먼트를 처리합니다.

/* include/uapi/linux/elf.h */
typedef struct elf64_phdr {
    Elf64_Word  p_type;    /* 세그먼트 타입 */
    Elf64_Word  p_flags;   /* 세그먼트 권한: PF_R|PF_W|PF_X */
    Elf64_Off   p_offset;  /* 파일 내 세그먼트 시작 오프셋 */
    Elf64_Addr  p_vaddr;   /* 메모리에 매핑될 가상 주소 */
    Elf64_Addr  p_paddr;   /* 물리 주소 (사용되지 않음) */
    Elf64_Xword p_filesz;  /* 파일 내 세그먼트 크기 */
    Elf64_Xword p_memsz;   /* 메모리 내 세그먼트 크기 (≥ p_filesz) */
    Elf64_Xword p_align;   /* 정렬 요구사항 */
} Elf64_Phdr;

커널이 처리하는 주요 세그먼트 타입:

섹션 헤더 — 섹션 (Section Headers)

섹션 헤더 테이블은 링커가 오브젝트 파일을 조합할 때 사용하는 정보입니다. 실행 시에는 프로그램 헤더(세그먼트)만 필수이며, 섹션 헤더는 선택 사항입니다. 하지만 디버깅과 심볼 분석에 중요합니다.

/* include/uapi/linux/elf.h */
typedef struct elf64_shdr {
    Elf64_Word  sh_name;       /* 섹션 이름 (.shstrtab 내 오프셋) */
    Elf64_Word  sh_type;       /* 섹션 타입: SHT_PROGBITS, SHT_SYMTAB 등 */
    Elf64_Xword sh_flags;      /* 플래그: SHF_WRITE, SHF_ALLOC, SHF_EXECINSTR */
    Elf64_Addr  sh_addr;       /* 메모리 내 주소 (로드 가능 시) */
    Elf64_Off   sh_offset;     /* 파일 내 섹션 시작 오프셋 */
    Elf64_Xword sh_size;       /* 섹션 크기 */
    Elf64_Word  sh_link;       /* 연관된 섹션 인덱스 */
    Elf64_Word  sh_info;       /* 추가 정보 */
    Elf64_Xword sh_addralign;  /* 정렬 제약 */
    Elf64_Xword sh_entsize;    /* 테이블 엔트리 크기 (고정 크기 테이블인 경우) */
} Elf64_Shdr;

주요 섹션과 그 역할:

심볼 테이블 (Symbol Table)

심볼 테이블은 프로그램에서 사용되는 함수, 변수, 섹션 등의 이름과 속성을 기록합니다. ELF에는 두 종류의 심볼 테이블이 있습니다: .symtab(전체 심볼, strip 시 제거 가능)과 .dynsym(동적 심볼, 런타임 필수이므로 제거 불가).

/* include/uapi/linux/elf.h */
typedef struct elf64_sym {
    Elf64_Word    st_name;   /* 심볼 이름 (.strtab/.dynstr 내 오프셋) */
    unsigned char st_info;   /* 바인딩(상위 4비트) + 타입(하위 4비트) */
    unsigned char st_other;  /* 가시성 (하위 2비트) */
    Elf64_Half    st_shndx;  /* 심볼이 속한 섹션 인덱스 */
    Elf64_Addr    st_value;  /* 심볼 값 (주소 또는 오프셋) */
    Elf64_Xword   st_size;   /* 심볼 크기 (바이트) */
} Elf64_Sym;

/* st_info 매크로 */
#define ELF64_ST_BIND(info)       ((info) >> 4)
#define ELF64_ST_TYPE(info)       ((info) & 0xf)
#define ELF64_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf))

/* st_other 매크로 */
#define ELF64_ST_VISIBILITY(other) ((other) & 0x3)

심볼 바인딩(Binding) — 심볼의 링킹 범위를 결정합니다:

심볼 타입(Type) — 심볼이 참조하는 엔티티의 종류:

심볼 가시성(Visibility) — 동적 링킹에서의 심볼 노출 범위를 제어합니다:

특수 섹션 인덱스 (st_shndx):

# 심볼 테이블 확인 예시
$ readelf -s /bin/ls | head -20
Symbol table '.dynsym' contains 127 entries:
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND
     1: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND abort@GLIBC_2.2.5
     2: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND __errno_location@GLIBC_2.2.5
    ...
    60: 000000000001f060   920 FUNC    GLOBAL DEFAULT   16 main
    61: 0000000000023400     8 OBJECT  GLOBAL DEFAULT   26 stdout

# Weak 심볼 예시 — 정의 없어도 링킹 성공
$ nm -D /lib/x86_64-linux-gnu/libc.so.6 | grep ' W '
0000000000044f10 W  pthread_cond_signal@@GLIBC_2.3.2
0000000000044a00 W  pthread_mutex_lock@@GLIBC_2.2.5

# IFUNC 심볼 — 런타임 최적 구현 선택
$ readelf -s /lib/x86_64-linux-gnu/libc.so.6 | grep IFUNC | head -5
   132: 00000000001a3700    0 IFUNC   GLOBAL DEFAULT   16 memcpy@@GLIBC_2.14
   156: 00000000001a37a0    0 IFUNC   GLOBAL DEFAULT   16 memset@@GLIBC_2.2.5
   173: 00000000001a37f0    0 IFUNC   GLOBAL DEFAULT   16 strcmp@@GLIBC_2.2.5

문자열 테이블 (String Tables)

ELF의 문자열 테이블은 NUL(\0)로 종료되는 문자열의 연속 배열입니다. 심볼 이름, 섹션 이름 등은 문자열을 직접 저장하지 않고, 해당 문자열 테이블 내의 바이트 오프셋을 참조합니다.

  오프셋:  0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18
  내용:  \0   m   a   i   n  \0   p   r   i   n   t   f  \0   _   s   t   a   r   t  \0

  st_name = 1  → "main"
  st_name = 6  → "printf"
  st_name = 13 → "_start"
  st_name = 0  → "" (빈 문자열, 이름 없는 심볼)

재배치 (Relocation)

재배치(Relocation)는 링커(정적) 또는 동적 링커(런타임)가 심볼 참조를 최종 주소로 해석하는 과정입니다. 오브젝트 파일에서 아직 결정되지 않은 주소(외부 함수, 전역 변수 등)는 재배치 엔트리로 기록되며, 링킹 시 실제 주소로 패치됩니다.

/* include/uapi/linux/elf.h */

/* Rel: 암시적 addend (코드 내 기존 값을 addend로 사용) */
typedef struct elf64_rel {
    Elf64_Addr  r_offset;  /* 패치할 위치 (섹션 내 오프셋 또는 가상 주소) */
    Elf64_Xword r_info;    /* 심볼 인덱스(상위 32비트) + 재배치 타입(하위 32비트) */
} Elf64_Rel;

/* Rela: 명시적 addend 포함 (x86_64에서 표준) */
typedef struct elf64_rela {
    Elf64_Addr   r_offset;  /* 패치할 위치 */
    Elf64_Xword  r_info;    /* 심볼 인덱스 + 재배치 타입 */
    Elf64_Sxword r_addend;  /* 주소 계산에 더해지는 상수 */
} Elf64_Rela;

#define ELF64_R_SYM(info)        ((info) >> 32)
#define ELF64_R_TYPE(info)       ((info) & 0xffffffff)

x86_64 주요 재배치 타입:

계산식에서: S = 심볼 값, A = addend, P = 패치 위치 주소, B = base address, L = PLT 엔트리 주소, TP = Thread Pointer.

동적 섹션 (.dynamic)

.dynamic 섹션은 동적 링커가 사용하는 메타데이터 테이블입니다. PT_DYNAMIC 세그먼트가 이 섹션을 가리키며, 런타임에 메모리에 로드되어 동적 링커가 라이브러리 로딩, 심볼 해석, 재배치를 수행하는 데 필요한 모든 정보를 제공합니다.

/* include/uapi/linux/elf.h */
typedef struct elf64_dyn {
    Elf64_Sxword d_tag;   /* 엔트리 타입 (DT_*) */
    union {
        Elf64_Xword  d_val;  /* 정수 값 */
        Elf64_Addr   d_ptr;  /* 주소 값 */
    } d_un;
} Elf64_Dyn;

주요 동적 태그:

# 동적 섹션 확인
$ readelf -d /bin/ls

Dynamic section at offset 0x22df0 contains 28 entries:
  Tag        Type                         Name/Value
 0x0000000000000001 (NEEDED)             Shared library: [libselinux.so.1]
 0x0000000000000001 (NEEDED)             Shared library: [libc.so.6]
 0x000000000000000c (INIT)               0x4000
 0x000000000000000d (FINI)               0x172e4
 0x0000000000000019 (INIT_ARRAY)         0x23b90
 0x000000006ffffef5 (GNU_HASH)           0x3a0
 0x0000000000000005 (STRTAB)             0xec0
 0x0000000000000006 (SYMTAB)             0x3d8
 0x000000000000001e (FLAGS)              BIND_NOW
 0x000000006ffffffb (FLAGS_1)            Flags: NOW PIE
 0x0000000000000000 (NULL)               0x0

ELF 노트 섹션 (Note Sections)

ELF 노트는 벤더별 메타데이터를 구조화된 형태로 저장하는 섹션입니다. .note.* 섹션과 PT_NOTE 세그먼트에 포함되며, 각 노트는 이름-타입-설명의 삼중 구조를 가집니다.

/* ELF 노트 헤더 — 각 노트 앞에 위치 */
typedef struct elf64_note {
    Elf64_Word n_namesz;  /* 이름 문자열 길이 (NUL 포함) */
    Elf64_Word n_descsz;  /* 설명(descriptor) 데이터 크기 */
    Elf64_Word n_type;    /* 노트 타입 (이름별 의미가 다름) */
    /* 이후: 이름(4바이트 정렬) + 설명(4바이트 정렬) */
} Elf64_Nhdr;

주요 GNU 노트 타입:

# 노트 섹션 확인
$ readelf -n /bin/ls

Displaying notes found in: .note.gnu.property
  Owner                Data size        Description
  GNU                  0x00000020       NT_GNU_PROPERTY_TYPE_0
      Properties: x86 feature: IBT, SHSTK
                  x86 ISA needed: x86-64-baseline

Displaying notes found in: .note.gnu.build-id
  Owner                Data size        Description
  GNU                  0x00000014       NT_GNU_BUILD_ID (unique build ID bitstring)
    Build ID: 2b0e4e5b0c7c0a4f3e6d...

Displaying notes found in: .note.ABI-tag
  Owner                Data size        Description
  GNU                  0x00000010       NT_GNU_ABI_TAG (ABI version tag)
    OS: Linux, ABI: 3.2.0

exec() 처리 흐름 (Execution Flow)

execve() 시스템 콜이 호출되면 커널은 다음 단계를 거쳐 프로세스 이미지를 교체합니다:

1. 바이너리 열기: open_exec()으로 실행 파일을 열고, struct file을 얻습니다.
2. bprm 구조체 준비: struct linux_binprm에 파일 첫 256바이트(매직 넘버 검사용), credentials, 파일 정보를 채웁니다.
3. 포맷 핸들러 탐색: search_binary_handler()가 등록된 바이너리 포맷 핸들러(struct linux_binfmt)를 순회하며, 매직 넘버를 통해 ELF, 스크립트(#!), misc 등 적절한 핸들러를 찾습니다.
4. ELF 헤더 검증: load_elf_binary()가 매직 넘버(0x7f ELF), 클래스(32/64bit), 엔디안, 아키텍처(e_machine)를 검증합니다.
5. 인터프리터 로딩: PT_INTERP 세그먼트가 있으면 동적 링커(예: /lib64/ld-linux-x86-64.so.2)의 ELF 파일을 별도로 로드합니다.
6. 기존 주소 공간 해제: begin_new_exec()에서 point-of-no-return을 넘기고, exec_mmap()으로 기존 mm_struct를 해제합니다.
7. PT_LOAD 세그먼트 매핑: elf_map()으로 각 PT_LOAD 세그먼트를 do_mmap()하여 파일 내용을 가상 주소 공간에 매핑합니다.
8. BSS 설정: set_brk()로 .bss 영역(p_memsz > p_filesz 차이분)을 익명 매핑으로 할당합니다.
9. 스택 설정: 새 스택에 argv, envp, auxiliary vector(AT_*)를 배치합니다.
10. 실행 시작: start_thread()로 레지스터를 설정하고, 동적 링크 바이너리이면 인터프리터의 엔트리 포인트에서, 아니면 ELF의 e_entry에서 실행을 시작합니다.

/* ELF 바이너리 로더 - fs/binfmt_elf.c (간략화) */
static int load_elf_binary(struct linux_binprm *bprm)
{
    struct elfhdr *elf_ex = (struct elfhdr *)bprm->buf;
    struct elf_phdr *elf_ppnt, *elf_phdata;
    struct elfhdr *interp_elf_ex = NULL;
    unsigned long load_addr = 0, load_bias = 0;
    unsigned long elf_entry;
    int executable_stack = EXSTACK_DEFAULT;

    /* 1. ELF 매직 넘버 및 타입 검증 */
    if (memcmp(elf_ex->e_ident, ELFMAG, SELFMAG) != 0)
        return -ENOEXEC;
    if (elf_ex->e_type != ET_EXEC && elf_ex->e_type != ET_DYN)
        return -ENOEXEC;

    /* 2. 프로그램 헤더 테이블 전체 읽기 */
    elf_phdata = load_elf_phdrs(elf_ex, bprm->file);

    /* 3. 프로그램 헤더 1차 순회: PT_INTERP, PT_GNU_STACK 처리 */
    for (i = 0; i < elf_ex->e_phnum; i++, elf_ppnt++) {
        if (elf_ppnt->p_type == PT_INTERP) {
            /* 동적 링커 경로 읽기 (예: /lib64/ld-linux-x86-64.so.2) */
            elf_interpreter = kmalloc(elf_ppnt->p_filesz, GFP_KERNEL);
            elf_read(bprm->file, elf_interpreter,
                     elf_ppnt->p_filesz, elf_ppnt->p_offset);
            /* 인터프리터 ELF 파일도 별도로 열어서 헤더 로드 */
            interp_elf_ex = ...;
        }
        if (elf_ppnt->p_type == PT_GNU_STACK) {
            /* 스택 실행 권한 결정 */
            executable_stack = (elf_ppnt->p_flags & PF_X)
                ? EXSTACK_ENABLE_X : EXSTACK_DISABLE_X;
        }
    }

    /* 4. Point of no return — 기존 주소 공간 해제 */
    begin_new_exec(bprm);
    setup_new_exec(bprm);

    /* 5. ET_DYN(PIE)이면 ASLR용 load_bias 계산 */
    if (elf_ex->e_type == ET_DYN) {
        load_bias = ELF_ET_DYN_BASE;  /* ASLR randomization 적용 */
        if (current->flags & PF_RANDOMIZE)
            load_bias += arch_mmap_rnd();
    }

    /* 6. PT_LOAD 세그먼트 매핑 */
    for (i = 0; i < elf_ex->e_phnum; i++) {
        if (elf_ppnt->p_type != PT_LOAD)
            continue;
        /* elf_map() → do_mmap(): 파일을 가상 주소에 매핑 */
        error = elf_map(bprm->file,
                        load_bias + vaddr,  /* 매핑 주소 */
                        elf_ppnt,           /* 세그먼트 정보 */
                        elf_prot, elf_flags, total_size);
    }

    /* 7. BSS 영역 설정 (p_memsz > p_filesz 부분) */
    set_brk(elf_bss, elf_brk, bss_prot);

    /* 8. 인터프리터가 있으면 로드 */
    if (interp_elf_ex)
        elf_entry = load_elf_interp(interp_elf_ex, ...);
    else
        elf_entry = elf_ex->e_entry + load_bias;

    /* 9. auxiliary vector를 스택에 배치 */
    create_elf_tables(bprm, elf_ex, interp_load_addr,
                      e_entry, phdr_addr);

    /* 10. 엔트리 포인트에서 실행 시작 */
    start_thread(regs, elf_entry, bprm->p);
    return 0;
}

Auxiliary Vector (보조 벡터)

커널은 exec() 시 사용자 공간 스택에 auxiliary vector(보조 벡터)를 배치합니다. 이 벡터는 동적 링커(ld-linux.so)와 C 라이브러리가 프로세스 환경을 파악하는 데 사용하는 키-값 쌍입니다.

스택 레이아웃 (낮은 주소 → 높은 주소):

주요 auxiliary vector 엔트리 (create_elf_tables()에서 생성):

# auxiliary vector 확인 방법
$ LD_SHOW_AUXV=1 /bin/true
AT_SYSINFO_EHDR:      0x7ffd5c9fe000    # vDSO 주소
AT_HWCAP:             178bfbff          # CPU 기능 비트맵
AT_PAGESZ:            4096              # 페이지 크기
AT_CLKTCK:            100               # clock ticks/sec
AT_PHDR:              0x55a3c4200040    # 프로그램 헤더 주소
AT_PHENT:             56                # phdr 엔트리 크기
AT_PHNUM:             13                # phdr 엔트리 수
AT_BASE:              0x7f2e8c400000    # ld.so 기본 주소
AT_ENTRY:             0x55a3c4201a90    # _start 주소
AT_RANDOM:            0x7ffd5c9d4a09    # 16바이트 난수 위치
AT_EXECFN:            /bin/true
AT_PLATFORM:          x86_64

ASLR과 PIE (Address Space Layout Randomization)

ASLR은 프로세스의 주요 메모리 영역(스택, 힙, mmap, 실행 코드)의 기본 주소를 매 실행마다 랜덤화하여 공격자가 코드/데이터 위치를 예측하기 어렵게 만듭니다.

/* load_elf_binary()에서 PIE(ET_DYN) ASLR 처리 */
if (elf_ex->e_type == ET_DYN) {
    /*
     * ET_DYN 바이너리는 상대 주소로 컴파일되어 임의 위치에 로드 가능.
     * ELF_ET_DYN_BASE는 아키텍처별 기본 주소:
     *   x86_64: (1UL << 47) * 2 / 3  ≈ 0x555555555000 부근
     */
    load_bias = ELF_ET_DYN_BASE;
    if (current->flags & PF_RANDOMIZE)
        load_bias += arch_mmap_rnd();
    load_bias = ELF_PAGESTART(load_bias);
}

/* ET_EXEC는 ELF에 지정된 고정 가상 주소에 로드 (ASLR 불가) */
if (elf_ex->e_type == ET_EXEC)
    load_bias = 0;  /* p_vaddr를 그대로 사용 */

# ASLR 수준 확인 및 설정
$ cat /proc/sys/kernel/randomize_va_space
2    # 0=비활성, 1=스택+mmap+vDSO, 2=1+brk(힙)

# 같은 PIE 바이너리를 두 번 실행하면 주소가 다름
$ cat /proc/self/maps | head -1
55a3c4200000-55a3c4205000 r--p ...    # 첫 번째 실행
$ cat /proc/self/maps | head -1
564e8b400000-564e8b405000 r--p ...    # 두 번째 실행 (주소 변경됨)

동적 링킹 (Dynamic Linking)

동적 링크 바이너리의 경우, 커널은 실행 파일과 함께 동적 링커(인터프리터)를 메모리에 로드하고, 인터프리터의 엔트리 포인트에서 실행을 시작합니다. 동적 링커(ld-linux.so)는 실제 프로그램의 main()이 실행되기 전에 공유 라이브러리 로드와 심볼 재배치를 수행합니다.

GOT/PLT와 지연 바인딩(Lazy Binding): 외부 함수 호출은 PLT(Procedure Linkage Table)를 거칩니다. PLT 엔트리는 GOT(Global Offset Table)에서 실제 주소를 읽어 점프합니다. 최초 호출 시 GOT 엔트리는 PLT의 리졸버 코드를 가리키며, 리졸버가 심볼을 해석하여 GOT를 갱신합니다. 이후 호출은 GOT에서 직접 점프하여 오버헤드가 없습니다.

; PLT를 통한 printf() 호출 예시 (x86_64)

; 사용자 코드에서 printf 호출
call   printf@plt          ; → PLT 엔트리로 점프

; .plt 섹션의 printf 엔트리
printf@plt:
    jmp    *printf@GOTPLT(%rip)  ; GOT에서 주소 읽어 간접 점프
    ; 최초 호출 시 GOT는 아래 push를 가리킴 (리졸버로 이동)
    push   $0x3                   ; 재배치 인덱스
    jmp    .plt                   ; _dl_runtime_resolve 호출

; _dl_runtime_resolve()가 printf의 실제 주소를 찾아
; GOT 엔트리를 갱신 → 이후 호출은 직접 printf로 점프

vDSO (virtual Dynamic Shared Object)

vDSO는 커널이 모든 사용자 공간 프로세스의 주소 공간에 자동으로 매핑하는 특수한 공유 라이브러리입니다. gettimeofday(), clock_gettime(), getcpu() 등 빈번하게 호출되지만 실제 특권이 불필요한 시스템 콜을 커널 진입 없이 사용자 공간에서 처리할 수 있게 합니다.

/* vDSO 매핑 — arch/x86/entry/vdso/ */

/* 커널이 exec 시 vDSO를 매핑하는 과정 */
/* load_elf_binary() → arch_setup_additional_pages() */
int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)
{
    /* vDSO 이미지를 프로세스 주소 공간에 매핑 */
    return map_vdso(&vdso_image_64, 0);
    /* AT_SYSINFO_EHDR auxv 엔트리가 이 주소를 가리킴 */
}

/* vDSO 내 함수 예시: 시스템 콜 없이 시간 획득 */
int __vdso_clock_gettime(clockid_t clock, struct timespec *ts)
{
    /* 커널이 공유 메모리(vvar)에 갱신해둔 시간 데이터를 직접 읽음 */
    /* → syscall 오버헤드(~100ns) 제거 */
    ...
}

# vDSO 확인
$ cat /proc/self/maps | grep vdso
7ffd5c9fe000-7ffd5ca00000 r-xp 00000000 00:00 0    [vdso]

# vDSO가 export하는 심볼 확인
$ objdump -T /proc/self/root/usr/lib/vdso/vdso64.so 2>/dev/null || \
  dd if=/proc/self/mem bs=1 skip=$((0x7ffd5c9fe000)) count=8192 2>/dev/null | \
  readelf -Ws /dev/stdin 2>/dev/null
# __vdso_clock_gettime, __vdso_gettimeofday, __vdso_time, __vdso_getcpu

ELF 분석 도구 (Analysis Tools)

# readelf — ELF 구조 분석의 표준 도구
$ readelf -h /bin/ls           # ELF 헤더
$ readelf -l /bin/ls           # 프로그램 헤더 (세그먼트)
$ readelf -S /bin/ls           # 섹션 헤더
$ readelf -s /bin/ls           # 심볼 테이블
$ readelf -d /bin/ls           # 동적 섹션 (DT_NEEDED 등)
$ readelf -r /bin/ls           # 재배치 엔트리
$ readelf -n /bin/ls           # 노트 섹션 (빌드 ID 등)

# objdump — 디스어셈블리와 섹션 분석
$ objdump -d /bin/ls           # 코드 섹션 디스어셈블리
$ objdump -j .plt -d /bin/ls   # PLT 엔트리만 디스어셈블
$ objdump -R /bin/ls           # 동적 재배치 테이블

# nm — 심볼 목록
$ nm -D /bin/ls                # 동적 심볼만 표시

# ldd — 동적 라이브러리 의존성
$ ldd /bin/ls                  # 의존 공유 라이브러리와 로드 주소

# file — 파일 타입 식별
$ file /bin/ls
/bin/ls: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV),
         dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2,
         BuildID[sha1]=..., for GNU/Linux 3.2.0, stripped

TLS — Thread-Local Storage (스레드 로컬 저장소)

TLS(Thread-Local Storage)는 각 스레드가 독립적인 복사본을 가지는 변수를 구현하는 메커니즘입니다. C/C++에서 __thread 또는 _Thread_local 키워드로 선언하며, ELF에서는 PT_TLS 세그먼트와 TLS 관련 재배치로 구현됩니다.

/* TLS 변수 선언 예시 */
__thread int tls_var = 42;           /* 초기화됨 → .tdata 섹션 */
__thread int tls_bss_var;              /* 미초기화 → .tbss 섹션 */
_Thread_local char buf[256];          /* C11 표준 키워드 (동일) */

/* 커널 내 per-CPU 변수도 유사한 개념 */
DEFINE_PER_CPU(int, my_percpu_var);    /* 커널에서는 __percpu로 구현 */

TLS 관련 ELF 섹션과 세그먼트:

TLS 접근 모델: 컴파일러는 TLS 변수의 가시성과 링킹 상황에 따라 4가지 접근 모델을 사용합니다:

; Local Exec 모델 (x86_64) — 가장 효율적
; 실행 파일 자체의 TLS 변수 접근
mov  eax, dword ptr fs:[tls_var@TPOFF]  ; FS + 고정 오프셋

; Initial Exec 모델 — GOT에서 오프셋 로드
mov  rax, qword ptr [rip + tls_var@GOTTPOFF]  ; GOT에서 TP 오프셋
mov  eax, dword ptr fs:[rax]                   ; FS + 오프셋

; General Dynamic 모델 — __tls_get_addr() 호출
lea  rdi, [rip + tls_var@TLSGD]    ; TLS descriptor 주소
call __tls_get_addr@PLT              ; 동적 링커가 주소 반환
mov  eax, [rax]                      ; 반환된 주소로 접근

# TLS 세그먼트 확인
$ readelf -l /usr/bin/python3 | grep TLS
  TLS            0x000000000029a890 0x000000000049a890 0x000000000049a890
                 0x0000000000000010 0x0000000000000088  R      0x8

# TLS 심볼 확인
$ readelf -s /lib/x86_64-linux-gnu/libc.so.6 | grep TLS
    16: 0000000000000000    4 TLS     GLOBAL DEFAULT   32 errno@@GLIBC_PRIVATE
    18: 0000000000000008    8 TLS     GLOBAL DEFAULT   32 __resp@@GLIBC_PRIVATE

# TLS 관련 재배치
$ readelf -r /usr/bin/python3 | grep TPOFF
00000049c038  001b00000012 R_X86_64_TPOFF64  0000000000000000 _Py_tss_tstate + 0

코어 덤프 (Core Dump)

프로세스가 치명적 시그널(SIGSEGV, SIGABRT 등)을 받으면 커널은 프로세스의 메모리 상태를 ELF 코어 덤프 파일로 저장합니다. 코어 파일은 ET_CORE 타입의 ELF이며, 크래시 분석에 필수적인 정보를 포함합니다.

코어 덤프 생성 경로:

코어 파일 구조:

/* fs/binfmt_elf.c — 코어 덤프 핵심 함수 (간략화) */
static int elf_core_dump(struct coredump_params *cprm)
{
    struct elfhdr elf;
    struct elf_phdr *phdr;

    /* 1. ELF 헤더 작성 (ET_CORE) */
    fill_elf_header(&elf, segs + 1, ELF_ARCH, 0);
    elf.e_type = ET_CORE;

    /* 2. PT_NOTE 세그먼트 작성 — 레지스터, 시그널 정보 */
    fill_note(&psinfo_note, "CORE", NT_PRPSINFO, ...);
    fill_note(&siginfo_note, "CORE", NT_SIGINFO, ...);

    /* 각 스레드의 레지스터 상태 */
    for_each_thread(p, t) {
        fill_note(&t->prstatus_note, "CORE", NT_PRSTATUS,
                  sizeof(struct elf_prstatus), &t->prstatus);
    }

    /* 3. VMA 순회 — 각 메모리 영역을 PT_LOAD로 기록 */
    for_each_vma(cprm->mm, vma) {
        /* 코어 덤프 필터에 따라 포함 여부 결정 */
        if (!vma_dump_size(vma, cprm->mm_flags))
            continue;
        phdr->p_type = PT_LOAD;
        phdr->p_vaddr = vma->vm_start;
        phdr->p_memsz = vma->vm_end - vma->vm_start;
        /* 메모리 내용을 파일에 기록 */
        dump_user_range(cprm, vma->vm_start, size);
    }
}

# 코어 덤프 설정
$ cat /proc/sys/kernel/core_pattern
|/usr/lib/systemd/systemd-coredump %P %u %g %s %t %c %h

# 코어 덤프 필터 (비트마스크로 포함할 VMA 유형 제어)
$ cat /proc/self/coredump_filter
00000033    # bit 0: 익명 private, bit 1: 익명 shared
            # bit 4: ELF headers, bit 5: DAX private

# 코어 파일 분석
$ readelf -h core | grep Type
  Type:                              CORE (Core file)
$ readelf -n core | head -20
Displaying notes found at file offset 0x... with length 0x...:
  Owner     Data size   Description
  CORE      0x00000150  NT_PRSTATUS (prstatus structure)
  CORE      0x00000088  NT_PRPSINFO (prpsinfo structure)
  CORE      0x00000080  NT_SIGINFO (siginfo_t data)
  CORE      0x00000130  NT_AUXV (auxiliary vector)
  CORE      0x00000563  NT_FILE (mapped files)

# GDB로 코어 파일 분석
$ gdb /path/to/binary core
(gdb) bt                  # 크래시 시점 backtrace
(gdb) info registers      # 레지스터 상태
(gdb) x/10i $rip          # 크래시 위치 디스어셈블리

# systemd 환경에서 코어 덤프 조회
$ coredumpctl list
$ coredumpctl debug       # 최근 코어 덤프로 GDB 실행

커널 모듈 ELF (.ko)

커널 모듈(.ko 파일)은 ET_REL(재배치 가능) 타입의 ELF 오브젝트입니다. 일반 사용자 공간 실행 파일과 달리 프로그램 헤더가 없으며, 커널의 load_module()이 링커 역할을 수행하여 섹션 기반으로 로딩과 재배치를 처리합니다.

모듈 전용 ELF 섹션:

/* kernel/module/main.c — 모듈 로딩 핵심 흐름 (간략화) */
static int load_module(struct load_info *info, const char *uargs, int flags)
{
    /* 1. ELF 헤더 검증 (ET_REL, 아키텍처, 버전) */
    err = elf_validity_check(info);

    /* 2. 섹션 헤더 테이블 파싱 — 모든 섹션 정보 수집 */
    err = setup_load_info(info, flags);

    /* 3. .modinfo에서 vermagic 검증 */
    err = check_modinfo(info->mod, info, flags);
    /*    vermagic = "6.1.0 SMP preempt mod_unload" */

    /* 4. SHF_ALLOC 섹션을 core/init 영역으로 분류 */
    module_frob_arch_sections(info);
    err = move_module(info->mod, info);
    /*    vmalloc으로 메모리 할당, 섹션 데이터 복사 */

    /* 5. 심볼 해석 — 커널 심볼 테이블에서 외부 참조 검색 */
    err = simplify_symbols(info);
    /*    find_symbol() → __ksymtab 검색 → 심볼 주소 resolve */

    /* 6. 재배치 수행 */
    err = apply_relocations(info);
    /*    각 .rela.* 섹션에 대해 apply_relocate_add() 호출 */
    /*    모듈 코드 내 주소 참조를 실제 커널 심볼 주소로 패치 */

    /* 7. __ex_table, __bug_table 등 특수 섹션 등록 */
    post_relocation(info->mod, info);

    /* 8. 모듈 초기화 함수 실행 */
    return do_init_module(info->mod);
    /*    mod->init() 호출 후 .init.* 섹션 메모리 해제 */
}

# 커널 모듈의 ELF 구조 확인
$ readelf -h drivers/net/ethernet/intel/e1000e/e1000e.ko
ELF Header:
  Type:                              REL (Relocatable file)
  Machine:                           Advanced Micro Devices X86-64

# 모듈 전용 섹션 확인
$ readelf -S e1000e.ko | grep -E 'modinfo|ksymtab|init\.text|versions'
  [11] .modinfo          PROGBITS  ...
  [13] __versions        PROGBITS  ...
  [21] .init.text        PROGBITS  ...
  [35] __ksymtab         PROGBITS  ...
  [36] __ksymtab_gpl     PROGBITS  ...

# .modinfo 내용 확인
$ modinfo e1000e.ko
filename:       e1000e.ko
license:        GPL v2
description:    Intel(R) PRO/1000 Network Driver
author:         Intel Corporation
alias:          pci:v00008086d00001533...
depends:
vermagic:       6.1.0 SMP preempt mod_unload

# 모듈의 재배치 엔트리 — 커널 심볼 참조
$ readelf -r e1000e.ko | head -10
Relocation section '.rela.text' at offset ... contains 1234 entries:
  Offset          Info           Type           Sym. Value    Sym. Name + Addend
000000000054  002c00000002 R_X86_64_PC32     0000000000000000 printk - 4
00000000009e  003400000002 R_X86_64_PC32     0000000000000000 __kmalloc - 4

binfmt 핸들러 프레임워크 (Binary Format Handlers)

Linux 커널은 다양한 실행 파일 형식을 플러그인 방식으로 지원합니다. exec() 시스템 콜이 호출되면 커널은 등록된 바이너리 포맷 핸들러를 순회하며, 파일의 매직 넘버를 검사하여 적절한 핸들러를 찾습니다. 이 프레임워크의 핵심은 struct linux_binfmt입니다.

/* include/linux/binfmts.h */
struct linux_binfmt {
    struct list_head lh;               /* 전역 리스트 연결 */
    struct module *module;              /* 소유 모듈 (참조 카운트) */
    int (*load_binary)(struct linux_binprm *);  /* 바이너리 로드 */
    int (*load_shlib)(struct file *);              /* uselib() 지원 (레거시) */
    int (*core_dump)(struct coredump_params *cprm); /* 코어 덤프 생성 */
    unsigned long min_coredump;        /* 최소 코어 덤프 크기 */
};

커널에 내장된 주요 바이너리 포맷 핸들러:

/* fs/exec.c — 바이너리 포맷 핸들러 탐색 (간략화) */
static int search_binary_handler(struct linux_binprm *bprm)
{
    struct linux_binfmt *fmt;
    int retval;

    /* 등록된 모든 binfmt 핸들러를 순회 */
    list_for_each_entry(fmt, &formats, lh) {
        if (!try_module_get(fmt->module))
            continue;

        /* 각 핸들러의 load_binary() 호출 */
        retval = fmt->load_binary(bprm);
        module_put(fmt->module);

        if (retval == -ENOEXEC)
            continue;  /* 이 포맷이 아님 → 다음 핸들러 시도 */
        return retval; /* 성공(0) 또는 에러 → 탐색 종료 */
    }
    return retval;  /* -ENOEXEC: 어떤 핸들러도 인식하지 못함 */
}

/* fs/binfmt_elf.c — ELF 핸들러 등록 */
static struct linux_binfmt elf_format = {
    .module       = THIS_MODULE,
    .load_binary = load_elf_binary,    /* ELF 실행 파일 로드 */
    .load_shlib  = load_elf_library,   /* 레거시 uselib() */
    .core_dump   = elf_core_dump,      /* ET_CORE 코어 덤프 */
    .min_coredump = ELF_EXEC_PAGESIZE,
};

/* fs/binfmt_script.c — #! 스크립트 핸들러 */
static int load_script(struct linux_binprm *bprm)
{
    /* 첫 2바이트가 '#!' 인지 확인 */
    if ((bprm->buf[0] != '#') || (bprm->buf[1] != '!'))
        return -ENOEXEC;

    /* 인터프리터 경로 파싱 (예: /usr/bin/python3) */
    i_name = bprm->buf + 2;  /* '#!' 이후 */
    ...
    /* bprm의 파일을 인터프리터로 교체 후 재귀 호출 */
    bprm->interpreter = open_exec(i_name);
    return search_binary_handler(bprm);  /* 재귀! */
}

binfmt_misc — 사용자 정의 바이너리 핸들러: binfmt_misc는 사용자 공간에서 /proc/sys/fs/binfmt_misc를 통해 임의의 바이너리 포맷을 등록할 수 있는 강력한 확장 메커니즘입니다. 컨테이너 환경에서 다른 아키텍처의 바이너리를 투명하게 실행하는 데 특히 유용합니다.

# binfmt_misc 마운트 확인
$ mount | grep binfmt_misc
systemd-1 on /proc/sys/fs/binfmt_misc type binfmt_misc

# QEMU user-mode emulation 등록 (ARM64 바이너리를 x86_64에서 실행)
$ echo ':qemu-aarch64:M::\x7fELF\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\xb7\x00:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/bin/qemu-aarch64-static:FPC' \
    > /proc/sys/fs/binfmt_misc/register

# 등록된 핸들러 확인
$ cat /proc/sys/fs/binfmt_misc/qemu-aarch64
enabled
interpreter /usr/bin/qemu-aarch64-static
flags: FPC
offset 0
magic 7f454c460201010000000000000000000200b700
mask ffffffffffffff00fffffffffffffffffeffffff

# Java JAR 파일 직접 실행 등록
$ echo ':Java:M::\xca\xfe\xba\xbe::/usr/bin/java:' \
    > /proc/sys/fs/binfmt_misc/register

# Wine으로 PE (.exe) 바이너리 실행 등록 (매직: MZ)
$ echo ':DOSWin:M::MZ::/usr/bin/wine:' \
    > /proc/sys/fs/binfmt_misc/register

# 현재 등록된 모든 핸들러 확인
$ ls /proc/sys/fs/binfmt_misc/
qemu-aarch64  qemu-arm  Java  DOSWin  register  status

심볼 버저닝 (Symbol Versioning)

심볼 버저닝은 공유 라이브러리가 동일한 심볼의 여러 버전을 동시에 제공할 수 있게 하는 ELF 확장입니다. glibc는 이 메커니즘을 활용하여 하위 호환성을 유지하면서 ABI를 발전시킵니다. 버저닝 정보는 .gnu.version, .gnu.version_r, .gnu.version_d 섹션에 저장됩니다.

/* 심볼 버저닝 관련 ELF 구조체 */

/* .gnu.version — 심볼 버전 인덱스 테이블
 * .dynsym의 각 심볼에 1:1 대응하는 16비트 버전 인덱스 */
typedef struct {
    Elf64_Half vd_ndx;  /* 버전 인덱스 (0=local, 1=global, 2+=정의된 버전) */
} Elf64_Versym;

/* .gnu.version_d — 라이브러리가 정의(제공)하는 버전 */
typedef struct {
    Elf64_Half  vd_version;  /* 구조체 버전 (VER_DEF_CURRENT = 1) */
    Elf64_Half  vd_flags;    /* VER_FLG_BASE: 기본 버전 */
    Elf64_Half  vd_ndx;      /* 버전 인덱스 */
    Elf64_Half  vd_cnt;      /* Verdaux 엔트리 수 */
    Elf64_Word  vd_hash;     /* 버전 이름 ELF 해시 */
    Elf64_Word  vd_aux;      /* Verdaux 오프셋 */
    Elf64_Word  vd_next;     /* 다음 Verdef 오프셋 (0=마지막) */
} Elf64_Verdef;

/* .gnu.version_r — 바이너리가 요구(필요)하는 버전 */
typedef struct {
    Elf64_Half  vn_version;  /* 구조체 버전 (VER_NEED_CURRENT = 1) */
    Elf64_Half  vn_cnt;      /* Vernaux 엔트리 수 */
    Elf64_Word  vn_file;     /* 라이브러리 이름 오프셋 (.dynstr) */
    Elf64_Word  vn_aux;      /* Vernaux 오프셋 */
    Elf64_Word  vn_next;     /* 다음 Verneed 오프셋 (0=마지막) */
} Elf64_Verneed;

/* Vernaux — 요구 버전의 상세 항목 */
typedef struct {
    Elf64_Word  vna_hash;    /* 버전 이름 ELF 해시 */
    Elf64_Half  vna_flags;   /* VER_FLG_WEAK: 약한 버전 참조 */
    Elf64_Half  vna_other;   /* .gnu.version에서 사용하는 인덱스 */
    Elf64_Word  vna_name;    /* 버전 문자열 오프셋 (예: "GLIBC_2.17") */
    Elf64_Word  vna_next;    /* 다음 Vernaux 오프셋 (0=마지막) */
} Elf64_Vernaux;

glibc에서 심볼 버저닝이 동작하는 방식:

# .gnu.version 섹션 — 각 동적 심볼의 버전 인덱스
$ readelf -V /bin/ls

Version symbols section '.gnu.version' contains 120 entries:
 Addr: 0x0000000000004ab8  Offset: 0x004ab8  Link: 6 (.dynsym)
  000:   0 (*local*)       2 (GLIBC_2.3)     3 (GLIBC_2.14)    1 (*global*)
  004:   4 (GLIBC_2.3.4)   2 (GLIBC_2.3)     2 (GLIBC_2.3)     0 (*local*)

# .gnu.version_r — 필요한 버전 목록
Version needs section '.gnu.version_r' contains 1 entry:
 Addr: 0x0000000000004c48  Offset: 0x004c48  Link: 7 (.dynstr)
  000000: Version: 1  File: libc.so.6  Cnt: 7
  0x0010:   Name: GLIBC_2.14   Flags: none  Version: 3
  0x0020:   Name: GLIBC_2.3    Flags: none  Version: 2
  0x0030:   Name: GLIBC_2.3.4  Flags: none  Version: 4
  0x0040:   Name: GLIBC_2.17   Flags: none  Version: 5
  0x0050:   Name: GLIBC_2.28   Flags: none  Version: 6
  0x0060:   Name: GLIBC_2.34   Flags: none  Version: 7
  0x0070:   Name: GLIBC_2.2.5  Flags: none  Version: 8

# 특정 심볼의 버전 확인
$ objdump -T /bin/ls | grep memcpy
0000000000000000      DF *UND*  0000000000000000  GLIBC_2.14  memcpy

# glibc가 제공하는 memcpy 버전들 확인
$ objdump -T /lib/x86_64-linux-gnu/libc.so.6 | grep ' memcpy'
00000000000a7910 g    DF .text  0000000000000039  GLIBC_2.2.5 memcpy
0000000000098fc0 g    DF .text  0000000000000244 (GLIBC_2.14) memcpy

# 바이너리가 요구하는 최소 glibc 버전 확인
$ objdump -T /bin/ls | grep -oP 'GLIBC_\d+\.\d+(\.\d+)?' | sort -Vu | tail -1
GLIBC_2.34

스택 언와인딩과 .eh_frame (Stack Unwinding)

스택 언와인딩(unwinding)은 현재 실행 지점에서 호출 스택을 역추적하는 과정으로, 예외 처리(C++ throw/catch), 디버거 백트레이스, 시그널 처리, 성능 프로파일링에 필수적입니다. ELF에서는 .eh_frame과 .eh_frame_hdr 섹션에 DWARF CFI(Call Frame Information) 형식으로 언와인딩 정보를 저장합니다.

/* DWARF CFI 핵심 구조:  CIE (Common Information Entry) + FDE (Frame Description Entry) */

/* CIE — 공통 정보 엔트리: 함수군에 대한 공통 언와인딩 규칙 */
struct cie_record {
    uint32_t length;            /* CIE 크기 (0xffffffff이면 64비트 확장) */
    uint32_t cie_id;             /* 항상 0 (CIE 식별자) */
    uint8_t  version;            /* CFI 버전 (1 또는 3) */
    char     augmentation[];      /* "zR", "zPLR" 등 확장 문자열 */
    /* ULEB128 code_alignment_factor;   텍스트 정렬 단위 (x86_64: 1) */
    /* SLEB128 data_alignment_factor;   데이터 정렬 단위 (x86_64: -8) */
    /* ULEB128 return_address_register; RA 레지스터 번호 (x86_64: 16=RIP) */
    /* initial_instructions[];          초기 CFA 규칙 바이트코드 */
};

/* FDE — 프레임 기술 엔트리: 개별 함수의 언와인딩 규칙 */
struct fde_record {
    uint32_t length;            /* FDE 크기 */
    uint32_t cie_pointer;       /* 소속 CIE로의 오프셋 (≠0이면 FDE) */
    /* pc_begin;                    함수 시작 주소 (인코딩은 CIE augmentation에 따름) */
    /* pc_range;                    함수 크기 */
    /* instructions[];              DW_CFA_* 바이트코드: 주소별 프레임 규칙 변화 */
};

CFI 바이트코드의 핵심 개념: 각 명령어 주소에서 CFA(Canonical Frame Address)와 레지스터 복원 규칙을 정의합니다. CFA는 일반적으로 이전 프레임의 스택 포인터 값입니다.

# .eh_frame의 CIE/FDE 레코드 확인
$ readelf --debug-dump=frames /bin/ls | head -40

Contents of the .eh_frame section:

00000000 0000000000000014 00000000 CIE
  Version:               1
  Augmentation:          "zR"
  Code alignment factor: 1
  Data alignment factor: -8
  Return address column: 16
  Augmentation data:     1b      # DW_EH_PE_pcrel|DW_EH_PE_sdata4
  DW_CFA_def_cfa: r7 (rsp) ofs 8   # 초기: CFA = RSP + 8
  DW_CFA_offset: r16 (rip) at cfa-8 # RIP는 CFA-8에 저장됨

00000018 0000000000000024 0000001c FDE cie=00000000 pc=0000c040..0000c0a2
  DW_CFA_advance_loc: 4
  DW_CFA_def_cfa_offset: 16       # push 이후: CFA = RSP + 16
  DW_CFA_offset: r6 (rbp) at cfa-16 # RBP가 CFA-16에 저장됨
  DW_CFA_advance_loc: 4
  DW_CFA_def_cfa_register: r6 (rbp) # mov rbp,rsp 이후: CFA = RBP + 16

# .eh_frame_hdr — FDE 이진 검색 테이블
$ readelf --debug-dump=frames-interp /bin/ls 2>/dev/null | head -5

# PT_GNU_EH_FRAME 세그먼트 확인
$ readelf -l /bin/ls | grep EH_FRAME
  GNU_EH_FRAME   0x000000000000e8e4 0x000000000000e8e4 ...  R      0x4

# C++ 예외 테이블 확인
$ readelf -S /usr/bin/c++filt | grep except
  [15] .gcc_except_table PROGBITS  ...

커널 스택 언와인딩 — ORC vs DWARF:

/* arch/x86/include/asm/orc_types.h — ORC 엔트리 구조 (6바이트) */
struct orc_entry {
    s16 sp_offset;       /* SP 복원 오프셋 */
    s16 bp_offset;       /* BP 복원 오프셋 */
    unsigned sp_reg:4;   /* SP 기준 레지스터 (SP, BP, SP_INDIRECT 등) */
    unsigned bp_type:4;  /* BP 상태 (undefined, prev_sp, regs 등) */
    unsigned type:2;     /* 프레임 타입 (CALL, REGS, REGS_PARTIAL) */
    unsigned signal:1;   /* 시그널 프레임 여부 */
    unsigned end:1;      /* 언와인딩 종료 지점 */
} __packed;
/* .orc_unwind + .orc_unwind_ip 섹션에 저장
 * objtool이 정적 분석으로 각 명령어 주소의 프레임 상태를 사전 계산 */

/* arch/x86/kernel/unwind_orc.c — ORC 언와인더 핵심 루프 */
void __unwind_start(struct unwind_state *state,
                     struct task_struct *task, ...)
{
    /* IP → ORC 엔트리 테이블 이진 검색 */
    orc = orc_find(state->ip);
    ...
}

bool unwind_next_frame(struct unwind_state *state)
{
    struct orc_entry *orc = orc_find(state->ip);

    /* ORC 엔트리의 sp_reg/sp_offset으로 이전 SP 계산 */
    switch (orc->sp_reg) {
    case ORC_REG_SP:
        sp = state->sp + orc->sp_offset;  break;
    case ORC_REG_BP:
        sp = state->bp + orc->sp_offset;  break;
    ...
    }
    /* IP = *(sp - 8): 리턴 주소로 이전 프레임의 IP 복원 */
    state->ip = *((unsigned long *)sp - 1);
    state->sp = sp;
    return true;
}

DWARF 디버그 정보 (Debug Information)

DWARF(Debugging With Attributed Record Formats)는 ELF 바이너리에 포함되는 디버그 정보의 표준 형식입니다. 소스 수준 디버깅(GDB, LLDB), 심볼 해석, 소스-라인 매핑에 사용되며, 컴파일러가 -g 옵션으로 생성합니다. 현재 널리 사용되는 버전은 DWARF 4(-gdwarf-4, GCC 기본)와 DWARF 5(-gdwarf-5, Clang 기본)입니다.

/* DWARF DIE (Debugging Information Entry) 구조 개념
 * 각 DIE는 태그(종류)와 속성(키-값) 목록으로 구성됨
 * DIE는 트리 구조로 스코프를 표현 */

/* 예: 다음 C 코드의 DWARF DIE 표현 */
int add(int a, int b) { return a + b; }

/*
 * DIE 트리:
 * DW_TAG_compile_unit          ← 컴파일 유닛 (소스 파일)
 *   DW_AT_name:     "math.c"
 *   DW_AT_comp_dir: "/home/dev/project"
 *   DW_AT_language: DW_LANG_C11
 *   DW_AT_producer: "GCC 13.2.0"
 *   DW_AT_stmt_list: (→ .debug_line 오프셋)
 *
 *   DW_TAG_base_type            ← 기본 타입
 *     DW_AT_name:     "int"
 *     DW_AT_byte_size: 4
 *     DW_AT_encoding: DW_ATE_signed
 *
 *   DW_TAG_subprogram           ← 함수
 *     DW_AT_name:     "add"
 *     DW_AT_low_pc:   0x401000  ← 함수 시작 주소
 *     DW_AT_high_pc:  0x401020  ← 함수 끝 주소
 *     DW_AT_type:     → (int)   ← 반환 타입 참조
 *     DW_AT_frame_base: DW_OP_reg6(rbp)
 *
 *     DW_TAG_formal_parameter   ← 매개변수
 *       DW_AT_name:     "a"
 *       DW_AT_type:     → (int)
 *       DW_AT_location: DW_OP_fbreg(-20) ← RBP-20에 저장
 *
 *     DW_TAG_formal_parameter
 *       DW_AT_name:     "b"
 *       DW_AT_type:     → (int)
 *       DW_AT_location: DW_OP_fbreg(-24)
 */

# DWARF 디버그 섹션 크기 확인 — 디버그 정보가 바이너리보다 큰 경우가 흔함
$ readelf -S /usr/lib/debug/usr/bin/ls.debug | grep debug
  [28] .debug_aranges    PROGBITS  ... 000002d0  ...
  [29] .debug_info       PROGBITS  ... 00032a41  ...  # 200KB+
  [30] .debug_abbrev     PROGBITS  ... 00001e25  ...
  [31] .debug_line       PROGBITS  ... 0000d8a2  ...
  [32] .debug_str        PROGBITS  ... 00005e12  ...

# DIE 트리 덤프 — 함수와 변수의 디버그 정보 확인
$ readelf --debug-dump=info a.out | head -50

Contents of the .debug_info section:

  Compilation Unit @ offset 0x0:
   Length:        0x120
   Version:       5                # DWARF 5
   Unit Type:     DW_UT_compile
   Abbrev Offset: 0x0
   Pointer Size:  8

 <0><c>: Abbrev Number: 1 (DW_TAG_compile_unit)
    <d>   DW_AT_producer    : GNU C17 13.2.0
    <22>  DW_AT_language    : 29   (C11)
    <23>  DW_AT_name        : math.c
    <2a>  DW_AT_comp_dir    : /home/dev/project

 <1><3e>: Abbrev Number: 2 (DW_TAG_subprogram)
    <3f>  DW_AT_name        : add
    <43>  DW_AT_low_pc      : 0x401000
    <4b>  DW_AT_high_pc     : 32
    <4f>  DW_AT_type        : <0x70>

# 소스 줄 ↔ 기계어 주소 매핑
$ readelf --debug-dump=decodedline a.out
Decoded dump of debug contents of section .debug_line:

CU: math.c:
File name           Line number    Starting address    View    Stmt
math.c                        1            0x401000               x
math.c                        2            0x401004               x
math.c                        2            0x40100a
math.c                        2            0x401013               x

# addr2line — 주소를 소스 위치로 변환 (내부적으로 .debug_line 사용)
$ addr2line -e a.out -f 0x401004
add
/home/dev/project/math.c:2

# dwarfdump (libdwarf) — 더 상세한 DWARF 분석
$ dwarfdump --print-all a.out 2>/dev/null | head -20

Split DWARF와 debuginfod — 대규모 프로젝트의 디버그 정보 관리:

# Split DWARF 컴파일 — .dwo 파일 생성
$ gcc -g -gsplit-dwarf -c math.c -o math.o
$ ls math.*
math.c  math.dwo  math.o

# .dwo 파일 병합 (대규모 프로젝트)
$ dwp -e myapp -o myapp.dwp

# GNU Build ID 확인
$ readelf -n /bin/ls | grep 'Build ID'
    Build ID: 2f31f68c55e02a7e7a72ad2758e04bd50c4e1e3a

# debuginfod 설정 (Fedora/Ubuntu/Arch 기본 제공)
$ export DEBUGINFOD_URLS="https://debuginfod.elfutils.org/"
$ gdb /bin/ls
Reading symbols from /bin/ls...
Downloading separate debug info for /bin/ls...

# 수동으로 별도 디버그 파일 설치 (Debian/Ubuntu)
$ sudo apt install coreutils-dbgsym
# → /usr/lib/debug/.build-id/2f/31f68c...debug

# 스트립 + debuglink 생성
$ objcopy --only-keep-debug myapp myapp.debug
$ strip --strip-debug myapp
$ objcopy --add-gnu-debuglink=myapp.debug myapp

링커 스크립트 (Linker Script)

링커 스크립트는 링커(ld)에게 입력 섹션을 출력 세그먼트에 어떻게 배치할지 지시하는 설정 파일입니다. 사용자 공간 프로그램은 시스템 기본 링커 스크립트(ld --verbose)를 사용하지만, 커널(vmlinux.lds.S)과 부트로더, 펌웨어, 베어메탈 프로그램은 맞춤 링커 스크립트가 필수적입니다.

/* 기본 링커 스크립트 구조 — 섹션에서 세그먼트로의 매핑 */

/* ENTRY: 프로그램 진입점 (ELF e_entry에 설정) */
ENTRY(_start)

/* PHDRS: 출력 세그먼트(프로그램 헤더) 정의 */
PHDRS
{
    headers PT_PHDR  PHDRS;               /* 프로그램 헤더 자체 */
    interp  PT_INTERP;                    /* 인터프리터 경로 */
    text    PT_LOAD  FLAGS(5);            /* R-X: 코드 세그먼트 */
    rodata  PT_LOAD  FLAGS(4);            /* R--: 읽기 전용 데이터 */
    data    PT_LOAD  FLAGS(6);            /* RW-: 데이터 세그먼트 */
    dynamic PT_DYNAMIC FLAGS(6);          /* 동적 링킹 정보 */
    note    PT_NOTE  FLAGS(4);            /* 빌드 ID 등 메타데이터 */
    eh_frame PT_GNU_EH_FRAME FLAGS(4);    /* .eh_frame_hdr */
    stack   PT_GNU_STACK FLAGS(6);        /* 스택 속성 (NX) */
    relro   PT_GNU_RELRO FLAGS(4);        /* RELRO 영역 */
}

/* SECTIONS: 입력 섹션을 출력 섹션에 배치하고, 세그먼트에 할당 */
SECTIONS
{
    /* 코드 영역 — text 세그먼트 */
    .text : {
        *(.text .text.*)              /* 모든 입력의 .text 섹션 */
        *(.text.hot .text.hot.*)      /* 핫 코드 (PGO) */
    } :text                           /* → text 세그먼트에 배치 */

    /* 읽기 전용 데이터 — rodata 세그먼트 */
    .rodata : {
        *(.rodata .rodata.*)
    } :rodata

    /* 동적 링킹 — data 세그먼트 */
    .dynamic : { *(.dynamic) } :data :dynamic

    /* GOT/PLT — RELRO 보호 대상 */
    .got : { *(.got) } :data :relro
    .got.plt : { *(.got.plt) }

    /* 초기화된 데이터 */
    .data : { *(.data .data.*) } :data

    /* BSS — 파일에 저장되지 않음 (p_memsz > p_filesz) */
    .bss : { *(.bss .bss.*) *(COMMON) } :data

    /* PROVIDE: 심볼이 정의되지 않았을 때만 제공 */
    PROVIDE(_end = .);
    PROVIDE(__bss_start = ADDR(.bss));
}

리눅스 커널의 링커 스크립트 (vmlinux.lds.S): 커널은 아키텍처별 링커 스크립트 템플릿(arch/x86/kernel/vmlinux.lds.S)을 C 전처리기로 처리하여 최종 vmlinux.lds를 생성합니다. 커널만의 특수한 섹션 배치가 정의됩니다.

/* arch/x86/kernel/vmlinux.lds.S — 커널 링커 스크립트 (핵심 발췌) */

#include <asm-generic/vmlinux.lds.h>

SECTIONS
{
    . = __START_KERNEL;   /* x86_64: 0xffffffff81000000 */

    .text : AT(ADDR(.text) - LOAD_OFFSET) {
        _text = .;
        _stext = .;
        /* HEAD_TEXT: startup_64 등 부팅 초기 코드 */
        HEAD_TEXT
        /* TEXT_TEXT: 일반 커널 코드 */
        TEXT_TEXT
        ...
        _etext = .;
    }

    /* .init 영역: 부팅 후 해제되는 코드/데이터 */
    .init.text : AT(ADDR(.init.text) - LOAD_OFFSET) {
        _sinittext = .;
        INIT_TEXT        /* __init 매크로 함수들 */
        _einittext = .;
    }
    .init.data : AT(ADDR(.init.data) - LOAD_OFFSET) {
        INIT_DATA        /* __initdata 변수들 */
    }

    /* 커널 특수 섹션 */
    .altinstructions : {
        __alt_instructions = .;
        *(.altinstructions)       /* CPU 기능별 대체 명령어 */
        __alt_instructions_end = .;
    }

    __ex_table : {
        __start___ex_table = .;
        *(__ex_table)              /* 예외 테이블 */
        __stop___ex_table = .;
    }

    /* ORC 언와인더 데이터 */
    .orc_unwind_ip : {
        __start_orc_unwind_ip = .;
        *(.orc_unwind_ip)
        __stop_orc_unwind_ip = .;
    }
    .orc_unwind : {
        __start_orc_unwind = .;
        *(.orc_unwind)
        __stop_orc_unwind = .;
    }

    /* __start/__stop 심볼: 링커가 자동 생성하는 섹션 경계 포인터 */
    /* 커널 코드에서 for_each 매크로로 섹션 내용을 순회할 때 사용 */
}

# 시스템 기본 링커 스크립트 확인
$ ld --verbose 2>/dev/null | grep -A3 'SECTIONS'
SECTIONS
{
  PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x400000));
  . = SEGMENT_START("text-segment", 0x400000) + SIZEOF_HEADERS;

# 커널 빌드에서 생성된 실제 링커 스크립트
$ head -20 /usr/src/linux/vmlinux.lds
# 또는 빌드 디렉토리에서:
$ head -20 /lib/modules/$(uname -r)/build/vmlinux.lds

# 커스텀 링커 스크립트 사용 (임베디드/베어메탈)
$ gcc -T custom.ld -nostdlib -o firmware startup.o main.o

# 섹션→세그먼트 매핑 확인
$ readelf -l /bin/ls | head -30
Program Headers:
  Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
  PHDR           0x000040 0x0000000000000040 0x0000000000000040 0x0002d8 0x0002d8 R   0x8
  INTERP         0x000318 0x0000000000000318 0x0000000000000318 0x00001c 0x00001c R   0x1
  LOAD           0x000000 0x0000000000000000 0x0000000000000000 0x003a58 0x003a58 R   0x1000
  LOAD           0x004000 0x0000000000004000 0x0000000000004000 0x013581 0x013581 R E 0x1000
  LOAD           0x018000 0x0000000000018000 0x0000000000018000 0x007b10 0x007b10 R   0x1000
  LOAD           0x020000 0x0000000000020000 0x0000000000020000 0x001258 0x002560 RW  0x1000
  ...
 Section to Segment mapping:
  Segment Sections...
   00
   01     .interp
   02     .interp .note.gnu.property .note.gnu.build-id .note.ABI-tag .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt
   03     .init .plt .plt.got .plt.sec .text .fini
   04     .rodata .eh_frame_hdr .eh_frame
   05     .init_array .fini_array .data.rel.ro .dynamic .got .data .bss

ELF 보안 강화 기법 (Security Hardening)

현대 Linux 시스템은 ELF 바이너리에 다양한 보안 메커니즘을 적용하여 메모리 손상 취약점의 악용을 방어합니다. 이러한 기법들은 컴파일러, 링커, 커널이 협력하여 구현합니다.

# 바이너리의 보안 속성 종합 점검 — checksec 스크립트
$ checksec --file=/bin/ls
RELRO           STACK CANARY      NX            PIE             RPATH      RUNPATH      Symbols        FORTIFY  Fortified  Fortifiable  FILE
Full RELRO      Canary found      NX enabled    PIE enabled     No RPATH   No RUNPATH   No Symbols     Yes      5          15           /bin/ls

# 개별 보안 속성 수동 확인

# 1. NX (No-Execute Stack) — PT_GNU_STACK 세그먼트의 플래그 확인
$ readelf -l /bin/ls | grep GNU_STACK
  GNU_STACK      0x000000 0x0000000000000000 0x0000000000000000 0x000000 0x000000 RW  0x10
#                                                                                ^^ RW = NX 활성 (E 없음)

# 2. RELRO — PT_GNU_RELRO 세그먼트 존재 + BIND_NOW 확인
$ readelf -l /bin/ls | grep GNU_RELRO
  GNU_RELRO      0x01f9c8 0x000000000021f9c8 0x000000000021f9c8 0x000638 0x000638 R   0x1
$ readelf -d /bin/ls | grep BIND_NOW
 0x000000000000001e (FLAGS)     BIND_NOW
# Full RELRO = PT_GNU_RELRO + BIND_NOW (즉시 바인딩으로 GOT가 읽기 전용)

# 3. PIE — ELF 타입이 DYN (공유 오브젝트)이면 PIE
$ readelf -h /bin/ls | grep Type
  Type:                              DYN (Position-Independent Executable)

# 4. Stack Canary — __stack_chk_fail 심볼 참조 존재
$ readelf -s /bin/ls | grep stack_chk
     4: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND __stack_chk_fail@GLIBC_2.4

# 5. FORTIFY — __*_chk 함수 참조 확인
$ readelf -s /bin/ls | grep '_chk@'
     6: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND __printf_chk@GLIBC_2.3.4
    12: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND __memcpy_chk@GLIBC_2.3.4

Partial RELRO vs Full RELRO:

/* 커널의 ELF 보안 검사 — fs/binfmt_elf.c */

/* NX 스택 처리: PT_GNU_STACK 세그먼트의 PF_X 플래그로 결정 */
static int load_elf_binary(struct linux_binprm *bprm)
{
    ...
    for (i = 0; i < elf_ex->e_phnum; i++, elf_ppnt++) {
        if (elf_ppnt->p_type == PT_GNU_STACK) {
            if (elf_ppnt->p_flags & PF_X)
                executable_stack = EXSTACK_ENABLE_X;  /* 실행 가능 스택 */
            else
                executable_stack = EXSTACK_DISABLE_X;  /* NX 스택 (기본) */
        }
    }
    ...
    /* ASLR: 인터프리터와 바이너리의 로드 주소 무작위화 */
    if (elf_ex->e_type == ET_DYN) {  /* PIE 바이너리 */
        load_bias = ELF_ET_DYN_BASE;  /* 2/3 * TASK_SIZE */
        if (current->flags & PF_RANDOMIZE)
            load_bias += arch_mmap_rnd();  /* ASLR 오프셋 */
        load_bias = ELF_PAGESTART(load_bias);
    }
    ...
}

/* Stack Canary (커널 측): 프로세스 생성 시 랜덤 카나리 값 설정 */
/* include/linux/sched.h */
struct task_struct {
    ...
    unsigned long stack_canary;  /* copy_process()에서 get_random_canary()로 초기화 */
    ...
};
/* arch/x86에서는 per-cpu __stack_chk_guard 또는 gs:[0x28]에 저장 */

ELF 분석 플레이북

ELF 이슈는 링크 단계, 로더 단계, 런타임 단계로 나눠서 보면 원인 축소가 빠릅니다. 커널/모듈/유저 바이너리를 같은 도구로 교차 확인하면 문제를 빠르게 재현할 수 있습니다.

1. 헤더 확인: 클래스(ELF32/64), 엔디안, 머신 타입 점검
2. 섹션/세그먼트 확인: 로딩 가능한 PT_*와 디버그/심볼 섹션 분리 확인
3. 심볼/재배치 확인: undefined symbol, relocation 유형 점검
4. 보안 속성 확인: PIE, RELRO, NX, canary 등 정책 확인

# ELF 기본 헤더/세그먼트
readelf -h vmlinux
readelf -l vmlinux

# 심볼/재배치
nm -n vmlinux | head
readelf -r mymodule.ko | head

# 바이너리 타입 확인
file arch/x86/boot/bzImage
objdump -h mymodule.ko | head

관련 문서

ELF와 관련된 다른 주제를 더 깊이 이해하고 싶다면 다음 문서를 참고하세요.

• 부팅 과정 — 커널 이미지 로딩
• 빌드 시스템 — vmlinux ELF 생성
• 커널 모듈 — 모듈 ELF 형식
• 프로세스 관리 — 사용자 공간 ELF 로딩