Lộ trình học C/C++ chuyên sâu — bản chi tiết

Danh mục sách dùng trong lộ trình

GIAI ĐOẠN 0 — Nền tảng C (4-6 tuần)

0.1 Kiểu dữ liệu & storage class

Học gì: int/char/short/long, kích thước kiểu theo platform (32-bit vs 64-bit), signed/unsigned, storage class static/extern/auto/register. Để làm gì: Khi parse header giao thức (GTPv2-C, Diameter), bạn phải biết chính xác một trường là 8-bit hay 16-bit hay 32-bit để đọc đúng offset trong buffer nhị phân. Đọc sai kích thước kiểu = đọc sai toàn bộ field phía sau. static cần để hiểu tại sao một biến trong file .c không bị conflict linker khi có 2 file cùng tên biến. Đọc ở đâu: K&R Ch.2 (Types, Operators, Expressions) — lướt nhanh vì gần giống Java, chỉ chú ý phần size/signedness.

0.2 Con trỏ (pointer arithmetic, con trỏ hàm, con trỏ đa cấp)

Học gì: *, &, ptr + n di chuyển bao nhiêu byte tùy kiểu, con trỏ tới con trỏ (char **argv), con trỏ hàm (void (*callback)(int)). Để làm gì:

• Pointer arithmetic → duyệt buffer nhị phân byte-by-byte khi parse packet capture (đi từng byte trong payload GTP-U mà không copy dữ liệu ra chỗ khác)
• Con trỏ hàm → viết dispatch table để xử lý từng loại message Diameter (CCR, CCA, AAR…) mà không cần chuỗi if-else dài
• Con trỏ đa cấp → cần khi một hàm C phải trả về hoặc sửa đổi một con trỏ (ví dụ hàm alloc_buffer(char **out, size_t len)) Đọc ở đâu: K&R Ch.5 (Pointers and Arrays) — đọc kỹ 2-3 lần, quan trọng nhất cả cuốn sách. Phần con trỏ hàm nằm ở cuối Ch.5.

0.3 Quản lý bộ nhớ thủ công

Học gì: malloc/calloc/realloc/free, khi nào heap bị fragment, memory leak là gì, double free và use-after-free là gì. Để làm gì: Tool phân tích traffic 4G/5G của bạn chạy liên tục 24/7 — nếu leak dù chỉ vài byte mỗi packet, sau vài giờ chương trình sẽ crash vì hết RAM. Hiểu double-free/UAF là bước đệm bắt buộc trước khi học exploit buffer overflow ở Giai đoạn 3 (đây chính là 2 lớp bug phổ biến nhất trong CVE của C/C++ software). Đọc ở đâu: K&R Ch.5.4 (Storage allocation) là phần giới thiệu ngắn; đọc sâu hơn về heap fragmentation để dành tới CS:APP Ch.9 (Giai đoạn 1) — K&R không đi sâu phần này.

0.4 Struct, union, bitfield

Học gì: khai báo struct, alignment/padding (compiler tự chèn byte trống để căn chỉnh), union chia sẻ vùng nhớ, bitfield (unsigned flag : 1). Để làm gì: Đây là kỹ năng bạn dùng trực tiếp và thường xuyên nhất. GTPv2-C header có các trường như Version (3 bit), Piggybacking flag (1 bit), TEID flag (1 bit) nằm chung trong 1 byte — bitfield hoặc bit-mask thủ công là cách duy nhất map đúng cấu trúc này. Diameter AVP header dùng struct với padding phải hiểu rõ để không đọc lệch offset. Đọc ở đâu: K&R Ch.6 (Structures) — đọc kỹ toàn bộ, đặc biệt phần bitfield ở cuối chương.

0.5 Preprocessor

Học gì: #define, #ifdef/#ifndef, header guard, macro có tham số. Để làm gì: Định nghĩa hằng số cho message type code (#define GTP_ECHO_REQUEST 1) giúp code dễ đọc hơn magic number; header guard bắt buộc khi project có nhiều file .h include lẫn nhau (sẽ gặp ngay khi tách code parser thành nhiều module). Đọc ở đâu: K&R Ch.4.11 (The C Preprocessor) — ngắn, đọc hết trong một buổi là đủ.

Sách bổ sung cho cả giai đoạn — Modern C (Jens Gustedt, free PDF):

• Đọc kỹ: phần Undefined Behavior & Sequence Points (nền cho mục 0.2-0.3), phần const/restrict/volatile qualifiers (nền cho mục 0.4, và sau này là mục 4.2)
• Bỏ qua: lịch sử ngôn ngữ, macro _Generic

K&R phần không cần đọc kỹ ở giai đoạn này: Ch.1 (Tutorial) lướt nhanh nếu đã quen cú pháp; Ch.3 (Control flow) gần như bỏ qua vì giống Java; Ch.7 (I/O) chỉ cần biết printf/scanf; Ch.8 (UNIX System Interface) bỏ hẳn, lỗi thời — học syscall thật ở Giai đoạn 1 qua CS:APP.

→ Dự án chốt giai đoạn: Parser TLV đọc IE từ capture GTPv2-C/Diameter thật, in ra từng trường — áp dụng đồng thời cả 5 mục trên.

GIAI ĐOẠN 1 — Compiler / Linker / OS (6-8 tuần)

1.1 Build pipeline (preprocessing → compile → assembly → linking)

Học gì: gcc -E (chỉ preprocessing), -S (ra assembly), -c (ra object file .o), rồi linker gộp thành executable. Để làm gì: Khi Ghidra/IDA cho bạn assembly của một binary, bạn cần hiểu ngược chiều — assembly đó tương ứng với đoạn C nào — để làm reverse engineering hiệu quả. Không hiểu pipeline này thì đọc disassembly chỉ là học vẹt mnemonic. Đọc ở đâu: CS:APP Ch.3 (Machine-Level Representation of Programs) — đọc kỹ nhất chương này trong cả cuốn, đây là cầu nối trực tiếp C ↔ Assembly bạn dùng khi RE.

1.2 Memory layout của process (text/data/bss/heap/stack)

Học gì: Layout địa chỉ ảo, ASLR (Address Space Layout Randomization) làm gì, stack canary chống overflow như thế nào. Để làm gì: Bắt buộc trước khi học exploit ở Giai đoạn 3 — muốn overflow một buffer trên stack để ghi đè return address, bạn phải biết chính xác stack nằm ở đâu, lớn lên hay xuống, và ASLR làm việc đó khó ra sao. Đọc ở đâu: CS:APP Ch.9 (Virtual Memory) — đọc kỹ đặc biệt phần malloc implementation, vì đây cũng là chỗ giải thích heap fragmentation còn thiếu ở mục 0.3.

1.3 Undefined Behavior (UB)

Học gì: signed integer overflow, đọc biến chưa khởi tạo, strict aliasing violation. Để làm gì: Đây là nguồn bug ẩn nguy hiểm nhất trong C — compiler được phép làm bất cứ gì khi gặp UB (kể cả optimize code theo cách bạn không ngờ tới). Khi bạn viết fuzzing harness ở Giai đoạn 3, phần lớn crash tìm được sẽ xuất phát từ UB dạng này chứ không phải logic sai rõ ràng. Đọc ở đâu: CS:APP Ch.2 — chỉ phần số âm/tràn số (integer overflow), không cần đọc kỹ phần floating point. Bổ sung phần Sequence Points từ Modern C (đã đọc ở Giai đoạn 0) nếu cần ôn lại.

1.4 Makefile / CMake

Học gì: target, dependency, rule cơ bản trong Makefile; CMakeLists.txt tối thiểu. Để làm gì: Mọi project thực tế (kể cả srsRAN, OpenAirInterface bạn sẽ đụng ở Giai đoạn 4) đều dùng CMake — không biết đọc CMakeLists.txt thì không build được source code của chính công cụ bạn đang dùng hàng ngày. Đọc ở đâu: Không có chương sách cụ thể trong CS:APP/K&R — dùng tài liệu chính thức GNU Make + CMake official tutorial (cmake.org/cmake/help/latest/guide/tutorial), thực hành trực tiếp thay vì đọc lý thuyết.

1.5 Debugging: GDB & Valgrind

Học gì: breakpoint, watchpoint, print/x để xem memory, bt (backtrace); Valgrind memcheck để tìm leak. Để làm gì: Khi parser của bạn segfault trên một capture packet cụ thể, GDB là công cụ duy nhất cho bạn biết chính xác dòng code nào, giá trị con trỏ nào gây crash — thay vì đoán mò bằng printf. Đọc ở đâu: CS:APP có phụ lục ngắn về GDB (phần “Practical Performance” tools trong Ch.3) nhưng không đủ sâu — dùng tài liệu chính thức sourceware.org/gdb/documentation mục Getting Started, và Valgrind Quick Start Guide.

1.6 Syscalls & POSIX (file I/O, process, socket)

Học gì: open/read/write/close, fork/exec/wait, socket() với AF_PACKET/AF_INET. Để làm gì: Đây là nền tảng để tự viết công cụ capture packet thay vì phụ thuộc hoàn toàn vào tshark/Wireshark — dùng AF_PACKET để bắt raw Ethernet frame chứa GTP-U tunnel, tự parse mà không qua lớp trung gian nào. Đọc ở đâu: CS:APP Ch.8 (Exceptional Control Flow) — chỉ phần process (fork/exec/wait) và signal, không cần đọc phần trap/interrupt lý thuyết OS sâu. Phần socket API tra thêm ở Beej’s Guide to Network Programming (free online) vì CS:APP không đủ chi tiết cho AF_PACKET.

CS:APP phần không cần đọc kỹ: Ch.5 (Optimizing Program Performance) và Ch.12 (Concurrent Programming) — để dành Ch.12 tới khi học RTOS ở Giai đoạn 4; Ch.6 (Memory Hierarchy/Cache) chỉ cần biết khái niệm, không cần tối ưu cache lúc này.

→ Dự án chốt giai đoạn: Packet sniffer bằng raw socket, tự parse GTP-U header trực tiếp từ kernel, không dùng thư viện ngoài.

GIAI ĐOẠN 2 — C++ hiện đại (8-10 tuần)

2.1 OOP & vtable

Học gì: class, constructor/destructor, virtual, cơ chế vtable (bảng con trỏ hàm ẩn) đứng sau polymorphism. Để làm gì: Khi bạn RE một binary C++ bằng Ghidra, virtual call hiện ra dưới dạng gọi qua con trỏ tới vtable — không hiểu cơ chế này thì không đọc được luồng gọi hàm của binary C++ đã compile. Đọc ở đâu: A Tour of C++ (Stroustrup) Ch.4 (Classes) cho phần cú pháp OOP cơ bản. Cơ chế vtable bản thân không nằm trong sách này (sách chỉ dạy dùng, không dạy implementation detail) — tra riêng bằng bài viết chuẩn “C++ vtable layout Itanium ABI” khi cần RE thật.

2.2 RAII

Học gì: tài nguyên (memory, file handle, socket) được gắn với lifetime của object — tự giải phóng khi object ra khỏi scope. Để làm gì: Đây là cách C++ giải quyết chính vấn đề bạn học ở mục 0.3 (memory leak) — khi viết lại parser bằng C++, wrap buffer trong một class có destructor tự delete[] thì không còn phải nhớ gọi free thủ công, giảm hẳn 1 lớp bug. Đọc ở đâu: A Tour of C++ Ch.5 (Essential Operations) — đọc kỹ, đây là chương quan trọng nhất của cả cuốn với bạn.

2.3 Smart pointers

Học gì: unique_ptr (sở hữu độc quyền), shared_ptr (đếm reference), weak_ptr (tránh cyclic reference). Để làm gì: Thay thế hoàn toàn raw pointer + malloc/free trong code mới — nếu bạn viết công cụ correlation session (IMSI ↔ F-TEID ↔ IP) chạy lâu dài, dùng shared_ptr cho session object tránh được leak khi nhiều thread cùng tham chiếu một session. Đọc ở đâu: A Tour of C++ Ch.13 (Utilities) cho tổng quan; sau đó Effective Modern C++ Item 18-22 — nhóm quan trọng nhất cả cuốn Meyers, đọc kỹ từng item để hiểu đúng khi nào dùng unique_ptr vs shared_ptr.

2.4 Templates

Học gì: function template, class template cơ bản. Để làm gì: Viết một hàm parse IE tổng quát hoạt động với nhiều kiểu message khác nhau (GTPv2-C IE, Diameter AVP) mà không cần copy-paste code cho từng loại. Đọc ở đâu: A Tour of C++ Ch.8 (Templates) — đủ cho mức “dùng được”, không cần đọc sách chuyên sâu về template metaprogramming ở giai đoạn này.

2.5 STL (vector, map, unordered_map, algorithm)

Học gì: container chuẩn, iterator, các thuật toán có sẵn (sort, find). Để làm gì: unordered_map<TEID, SessionInfo> chính là cấu trúc dữ liệu tự nhiên cho bài toán correlation của bạn — tra cứu session theo F-TEID trong O(1) thay vì tự cài hash table bằng tay. Đọc ở đâu: A Tour of C++ Ch.11-12 (Containers, Algorithms) — không nằm trong danh sách chương “đọc kỹ” ban đầu nhưng nên đọc lướt qua vì STL dùng hàng ngày; tra cppreference.com khi cần chi tiết API cụ thể.

2.6 Move semantics

Học gì: rvalue reference, std::move, tại sao tránh copy không cần thiết. Để làm gì: Khi xử lý buffer lớn (packet capture file GB-size), move semantics tránh copy toàn bộ buffer mỗi lần truyền qua hàm — quan trọng cho performance khi xử lý traffic real-time. Đọc ở đâu: Effective Modern C++ Item 23-30 (Rvalue References, Move Semantics) — đọc kỹ, đây là phần C++ khác biệt nhiều nhất so với tư duy Java.

Effective Modern C++ phần bỏ qua lúc đầu: Item 31-34 (lambda nâng cao), Item 35-40 (concurrency) — quay lại khi thật sự viết code đa luồng. A Tour of C++ Ch.15-18 (concurrency) cũng để dành tương tự.

→ Dự án chốt giai đoạn: Viết lại parser bằng C++ dùng RAII + smart pointer, so sánh Valgrind output với bản C ở Giai đoạn 0.

GIAI ĐOẠN 3 — Nhánh Security (8-10 tuần, song song Giai đoạn 4)

3.1 Memory corruption (buffer overflow, format string, integer overflow)

Học gì: cách một buffer overflow ghi đè return address hoặc saved registers; format string bug (printf(user_input) thay vì printf("%s", user_input)). Để làm gì: Đây chính là lớp lỗi bạn sẽ tìm khi audit code parser giao thức viễn thông của bên thứ ba, hoặc tự kiểm tra code bạn viết ra có an toàn không trước khi deploy vào hệ thống production xử lý traffic thật. Đọc ở đâu: Hacking: The Art of Exploitation (Jon Erickson) Ch.0x300 (Exploitation) — đọc kỹ từng ví dụ, tự tay chạy lại, đây là chương cốt lõi của cả cuốn cho mục này.

3.2 Mitigation & bypass (NX/DEP, ASLR, stack canary, CFI)

Học gì: cơ chế bảo vệ hệ điều hành hiện đại và kỹ thuật cơ bản để bypass (ROP — Return Oriented Programming). Để làm gì: Hiểu để đánh giá đúng mức độ nghiêm trọng của một lỗ hổng bạn tìm được — một buffer overflow trên hệ thống có đầy đủ mitigation thường khó khai thác hơn nhiều so với hệ thống thiếu bảo vệ, việc này quyết định severity rating khi bạn viết báo cáo. Đọc ở đâu: Hacking Ch.0x300 chỉ nói buffer overflow cơ bản, không đủ sâu về ROP/mitigation bypass hiện đại (sách khá cũ) — bổ sung bằng thực hành trực tiếp trên pwn.college (module “Memory Errors” và “Return Oriented Programming”) sau khi xong Ch.0x300.

3.3 Static/dynamic analysis (đọc disassembly)

Học gì: map ngược instruction assembly (mov, call, jmp) về construct C tương ứng. Để làm gì: Bạn đã có Ghidra/IDA sẵn — kỹ năng này là cầu nối giữa việc “có công cụ” và “đọc hiểu được binary”, cần khi phân tích firmware của thiết bị telecom (eNodeB, modem baseband) không có source code. Đọc ở đâu: Ôn lại CS:APP Ch.3 (đã đọc ở mục 1.1) song song với Hacking Ch.0x200 (Programming) — phần liên quan trực tiếp đến exploitation, không cần đọc lại phần dạy C cơ bản trong chương này vì bạn đã qua Giai đoạn 0.

3.4 Fuzzing (AFL++, libFuzzer)

Học gì: viết harness gọi hàm parse với input random/mutated, chạy fuzzer để tìm crash. Để làm gì: Đây là ứng dụng trực tiếp nhất vào công việc bạn đang làm — viết harness cho chính hàm parse GTPv2-C IE hoặc Diameter AVP bạn tự viết, tìm input nào khiến parser crash trước khi đưa vào production, tránh trường hợp một packet malformed từ mạng làm sập cả pipeline monitoring. Đọc ở đâu: Không nằm trong Hacking (sách không cover fuzzing). Dùng tài liệu chính thức AFL++ (github.com/AFLplusplus/AFLplusplus — mục docs) và libFuzzer tutorial của LLVM.

3.5 Sanitizers (ASan, UBSan, MSan)

Học gì: compile với -fsanitize=address,undefined, đọc report khi có lỗi. Để làm gì: Bật thường trực khi phát triển — bắt được bug (heap overflow, UB) ngay tại thời điểm code chạy trong môi trường dev, thay vì để nó ẩn mình rồi bùng ra khi chạy fuzzing hoặc tệ hơn là ở production. Đọc ở đâu: Tài liệu chính thức Clang/GCC (clang.llvm.org/docs/AddressSanitizer.html) — không có trong sách nào ở danh sách, đây là công cụ mới hơn thời điểm các sách được viết.

Hacking phần không cần đọc: Ch.0x100 (giới thiệu, lịch sử hacking) — bỏ qua vì không cần thiết với trình độ đang có; Ch.0x400 (Networking) lướt nhanh vì bạn vốn đã mạnh phần này từ công việc telecom.

→ Dự án chốt giai đoạn: Fuzzing harness cho parser GTPv2-C/Diameter tự viết, tìm crash bằng AFL++, root-cause bằng GDB+ASan.

GIAI ĐOẠN 4 — Nhánh Embedded/Systems (8-12 tuần, song song Giai đoạn 3)

4.1 Bare-metal (startup code, vector table, linker script)

Học gì: chương trình chạy không có OS bên dưới — ai khởi tạo stack pointer, ai gọi main() đầu tiên. Để làm gì: Nền tảng bắt buộc trước khi đọc hiểu firmware của bất kỳ thiết bị nhúng nào trong hạ tầng viễn thông (base station module, IoT gateway) — không có OS nghĩa là không có process, không có syscall, mọi thứ bạn học ở Giai đoạn 1 về OS phải “tắt” đi và học lại từ đầu ở tầng thấp hơn. Đọc ở đâu: Making Embedded Systems (Elecia White) Ch.2-3 (thiết kế hệ thống, giao tiếp phần cứng cơ bản) — đọc kỹ, đây là phần nhập môn tư duy embedded quan trọng nhất sách.

4.2 Memory-mapped I/O & volatile

Học gì: ghi/đọc trực tiếp vào địa chỉ vật lý của thanh ghi phần cứng, tại sao compiler không được phép optimize những lần đọc/ghi này (volatile). Để làm gì: Nếu sau này bạn nối kết vào phần radio layer/SDR nghiêm túc hơn, driver cho radio front-end (điều khiển tần số, gain) thực chất là ghi trực tiếp vào register qua con trỏ volatile. Đọc ở đâu: Making Embedded Systems Ch.3 có đề cập nhưng không sâu về volatile — quay lại phần volatile qualifier trong Modern C (đã đọc ở Giai đoạn 0) để ôn cú pháp, sau đó tra datasheet MCU cụ thể (STM32 reference manual) cho phần register map thực tế.

4.3 Interrupt handling (ISR)

Học gì: interrupt vector table, race condition giữa ISR và main loop, cách bảo vệ dữ liệu chia sẻ (disable interrupt tạm thời, atomic operation). Để làm gì: Xử lý dữ liệu đến từ ADC/RF front-end trong SDR pipeline thường qua interrupt — hiểu race condition ở đây quyết định pipeline có mất sample hay đọc dữ liệu bị corrupt hay không. Đọc ở đâu: Making Embedded Systems Ch.7 (Multitasking) — đọc kỹ, chương này chuẩn bị tư duy trước khi vào RTOS thật ở mục 4.4.

4.4 RTOS (FreeRTOS/Zephyr)

Học gì: task, scheduler, mutex/semaphore, priority inversion. Để làm gì: Nếu bạn build một thiết bị đo/giám sát tín hiệu độc lập (không dùng full Linux), RTOS là lớp OS tối giản để chạy nhiều task (đọc RF, xử lý tín hiệu, gửi kết quả qua network) đồng thời trên một MCU. Đọc ở đâu: Making Embedded Systems Ch.7 cho khái niệm chung; sách không đi sâu API cụ thể — chuyển sang tài liệu chính thức Zephyr RTOS (docs.zephyrproject.org, mục Kernel Services) để thực hành trực tiếp task/mutex/semaphore.

4.5 Cross-compilation & linker script

Học gì: arm-none-eabi-gcc, viết .ld file định nghĩa vùng nhớ Flash/RAM cho MCU cụ thể. Để làm gì: Biên dịch code chạy trên ARM Cortex-M (STM32) từ máy Mac/x86 của bạn — không có bước này thì không thể đưa code lên chạy trên hardware thật. Đọc ở đâu: Không nằm trong Making Embedded Systems (sách thiên về tư duy thiết kế hơn toolchain chi tiết) — dùng tài liệu ARM GNU Toolchain chính thức và ví dụ linker script có sẵn trong STM32 HAL/CMSIS.

4.6 UART/SPI/I2C driver-level

Học gì: giao thức truyền dữ liệu nối tiếp cơ bản, viết driver đọc/ghi qua các bus này. Để làm gì: Hầu hết module RF/SDR giá rẻ giao tiếp với MCU qua SPI — để tự xây pipeline capture tín hiệu độc lập, đây là lớp code bắt buộc phải viết tay. Đọc ở đâu: Making Embedded Systems Ch.2-3 có đề cập giao tiếp phần cứng ở mức khái niệm; chi tiết giao thức (timing diagram SPI/I2C) tra trực tiếp datasheet của module RF cụ thể bạn dùng.

4.7 Đọc source srsRAN/OAI

Học gì: không phải “học” theo nghĩa sách vở — đây là bước đọc code C++ hệ thống lớn, thấy cách RAII/template/STL áp dụng vào code real-time thực tế. Để làm gì: Cầu nối trực tiếp từ kiến thức bạn học (Giai đoạn 2-4) sang công cụ bạn đã dùng cho radio research — hiểu source code nghĩa là bạn có thể tùy biến, patch, hoặc debug srsRAN/OAI thay vì chỉ dùng như black-box. Đọc ở đâu: Không có sách — đọc trực tiếp source code trên GitHub (srsRAN_4G/srsRAN_Project, openairinterface5g), bắt đầu từ module PHY layer vì đây là phần gần nhất với kiến thức bare-metal/RF vừa học.

Making Embedded Systems phần lướt qua: phần quy trình quản lý dự án, testing methodology trong sách — hữu ích nhưng không cấp thiết cho mục tiêu hiện tại.

→ Dự án chốt giai đoạn: Driver bare-metal đọc dữ liệu SPI từ MCU/module RF đơn giản; đọc một phần PHY layer của srsRAN.

Bảng tổng hợp nhanh: kỹ năng → ứng dụng trực tiếp vào công việc hiện tại

Ghi chú tổng quát

• Giai đoạn 0-2 học tuần tự, không nhảy cóc.
• Giai đoạn 3-4 chạy song song sau khi xong Giai đoạn 2.
• ROI nhanh nhất cho công việc hiện tại: Giai đoạn 0 → 1 → 3 (fuzzing parser).
• Luôn bật -fsanitize=address,undefined khi build project cá nhân.
• Học 1 chủ đề → code ngay ứng dụng tương ứng ở cột “Để làm gì” → quay lại đọc tiếp.