EntropyVerify 딥다이브
— AES-CTR로 '압축 불가능한 난수'를 디스크에 들이붓고, BLAKE3로 한 블록도 빠짐없이 검증하는 Rust 스토리지 검사 엔진

blamie/EntropyVerify. 저장장치(SSD·USB·SD카드)에 하드웨어 가속 AES-CTR 난수를 디스크 끝까지 써넣은 뒤 전부 다시 읽어, 한 블록이라도 깨졌으면 BLAKE3 체크섬으로 잡아내는 스토리지 검증 도구다. 낡고 느린 H2testw(윈도우 전용·단일 스레드)의 현대적 대안으로, 실제 용량 사기(가짜 용량 USB) 탐지와 PCIe 4.0/5.0 NVMe의 한계 속도 측정을 동시에 한다. 비결은 셋이다 — ① 하드웨어 AES-NI로 7GB/s 난수 생성, ② Direct I/O + 비동기 엔진(리눅스 io_uring · 윈도우 IOCP)으로 OS 캐시를 건너뛴 실측, ③ 코어 피닝 멀티스레드 + ratatui TUI 대시보드로 실시간 처리량 표시. (저장소: blamie/EntropyVerify · 언어 Rust 100% · 약 4,150줄 · 26개 모듈 · v1.0.0 / 2026-06-23 릴리스 · 라이선스 AGPL-3.0 · ★16 신생 — TrendShift 라이브 멘션, r/rust 화제)

1프로젝트 한줄 요약

"드라이브를 난수로 가득 채웠다가 다시 읽어 본다 — 다 똑같이 돌아오면 진짜, 하나라도 다르면 가짜이거나 고장."

좀 더 구체적으로, EntropyVerify는 Rust로 만든 명령줄(CLI) 도구이자 터미널 UI 앱입니다. entropy_verify --target-dir E:\test처럼 검사할 드라이브를 지정하면, 디스크의 빈 공간을 1GiB짜리 파일 여러 개로 나눠 각 파일을 2MiB 블록 단위로 AES-CTR 난수로 채워 씁니다(쓰기 단계). 그다음 그 파일들을 전부 다시 읽어, 각 블록의 난수를 같은 공식으로 재생성해 BLAKE3 해시가 일치하는지 대조합니다(검증 단계). 끝나면 마크다운 리포트(쓰기/읽기 속도, 피크 처리량, 깨진 블록 위치)를 드라이브에 남깁니다. 인자 없이 더블클릭하면 화살표로 드라이브를 고르는 대화형 TUI가 뜹니다.

이 문서가 파고드는 건 사용법만이 아니라 그 안의 시스템 프로그래밍입니다 — "데이터를 저장도 안 하는데 어떻게 검증하나(결정론적 난수)", "왜 버퍼를 4096바이트에 맞춰야 하나(Direct I/O)", "io_uring과 IOCP는 무엇이고 왜 7GB/s가 나오나". 암호·해시·비동기 I/O·무잠금 동시성·Rust unsafe를 한 레포에서 실물로 배우고 싶은 사람에게 드물게 좋은 교본입니다.

2왜 주목받는가

"20년 묵은 H2testw를, 현대 하드웨어(AES-NI·io_uring·NVMe)를 제대로 쓰는 Rust로 다시 썼다."

먼저, 풀려는 문제 — '용량을 속이는 디스크'와 '느린 검사 도구'

저장장치 검사에는 두 가지 고질적 문제가 있습니다. 하나는 가짜 용량(fake flash) — 싸구려 USB·SD카드가 펌웨어로 용량을 부풀려 파는 사기입니다. 다른 하나는 검사 도구가 너무 느린 것 — 표준 도구 H2testw는 단일 스레드 동기 I/O라, 7GB/s를 내는 PCIe 5.0 SSD를 검사하는 데 답답할 만큼 오래 걸립니다.

비결은 '현대 하드웨어를 제대로 쓴다'는 것

이 프로젝트가 r/rust에서 화제가 된 이유는 단순한 재구현이 아니라 하드웨어의 모든 가속 경로를 동원했기 때문입니다.

고전 도구들과 비교

3기술 스택 전체 지도

"전부 Rust. 외부 서비스·런타임 0. 의존성 목록만 봐도 '하드웨어를 직접 만진다'는 설계 의도가 읽힌다."

EntropyVerify는 데이터베이스도, 네트워크도, 외부 라이브러리 서버도 없는 순수 단일 바이너리입니다. 대신 의존성이 암호·비동기 I/O·동시성·OS 시스템콜에 또렷이 몰려 있어, Cargo.toml이 곧 아키텍처 설명서입니다.

① 암호 · 해시 (검사 데이터의 핵심)

② 비동기 I/O 엔진 (플랫폼별로 다른 OS API)

③ 동시성 · TUI · 시스템

④ 빌드 · 배포 — "최적화를 끝까지 짜낸다"

릴리스 프로파일과 빌드 스크립트도 성능 철학을 드러냅니다.

# Cargo.toml — release 프로파일
[profile.release]
opt-level = 3        # 최고 최적화
lto = "thin"         # 링크 시점 최적화(크레이트 경계 너머 인라인)
codegen-units = 1    # 병렬 컴파일 포기하고 최적화 품질↑
strip = true         # 심볼 제거 → 작은 바이너리
panic = "abort"      # 패닉 시 되감기 없이 즉시 종료(빠르고 작음)

.cargo/config.toml은 x86_64에 target-feature=+aes,+sse4.1을 박아 AES-NI·SSE4.1을 컴파일 시점에 켜고, build.rs는 타깃 아키텍처/OS를 감지해 cfg 플래그(has_aes_ni 등)를 내보냅니다. 즉 "이 바이너리는 현대 x86_64 + AES-NI를 가정하고 빌드된다"는 선언입니다.

4아키텍처 심화 분석 (난수 한 블록이 검증되기까지)

"두 개의 막 — 쓰기(난수를 들이붓는다)와 검증(되읽어 BLAKE3로 대조한다). 그 사이를 원자적 카운터와 채널이 잇는다."

전체 데이터 흐름 한 장

핵심은 상태기계 + 워커 풀 + 무잠금 통신입니다. 앱 전체가 Idle → Writing → Verifying → Complete/Failed 다섯 단계를 오가고, 무거운 일은 워커 스레드들이, 화면은 메인 스레드가 맡습니다. 아래에서 설계 포인트를 하나씩 봅니다.

설계 ① — 결정론적 난수: '기댓값을 저장하지 않는다'

가장 영리한 절약입니다. 보통 "쓴 걸 검증"하려면 기댓값을 어딘가 저장해 둬야 하는데, 그러면 검사 데이터만큼의 저장공간이 또 필요합니다. EntropyVerify는 난수를 (파일번호, 블록번호)에서 결정론적으로 생성하므로, 검증 때 같은 좌표로 같은 난수를 다시 만들어 비교하면 됩니다 — 기댓값 저장이 0입니다.

// crypto/datagen.rs — 논스를 좌표에서 유도
fn derive_nonce(file_index: u32, block_index: u32) -> [u8; 16] {
    let mut nonce = [0u8; 16];
    nonce[0..4].copy_from_slice(&file_index.to_le_bytes());
    nonce[4..8].copy_from_slice(&block_index.to_le_bytes());
    // 8..16 바이트는 0 — CTR 카운터 공간
    nonce
}
// 0으로 채운 버퍼에 키스트림을 XOR → 결과 = 순수 난수
buf.fill(0);
cipher.apply_keystream(buf);

설계 ② — 블록 포맷: 64바이트 헤더 + 2MiB 페이로드, 제로카피로

각 2MiB 블록은 앞 64바이트가 구조화된 헤더(매직 EVFY·버전·스레드ID·파일/블록번호·AES 논스·BLAKE3 해시)이고 나머지가 난수 페이로드입니다. 헤더 구조체는 #[repr(C)] + bytemuck::Pod라, 복사·직렬화 라이브러리 없이 메모리 표현을 그대로 바이트로 보고 되돌립니다(제로카피).

// engine/block.rs
#[repr(C)]
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
pub struct BlockHeader {
    pub magic: [u8; 4],       // "EVFY"
    pub version: u8, pub _pad: u8, pub thread_id: u16,
    pub file_index: u32, pub block_index: u32,
    pub aes_nonce: [u8; 16],  // 이 블록을 만든 논스
    pub blake3_hash: [u8; 32],// 페이로드의 BLAKE3
}
// 컴파일 시점에 크기를 못박는다 — 64B가 아니면 빌드 실패
const _: () = assert!(std::mem::size_of::<BlockHeader>() == 64);

저 컴파일 타임 단언(const _: () = assert!(…))이 백미입니다 — 구조체 필드를 잘못 건드려 크기가 틀어지면 실행이 아니라 컴파일에서 잡힙니다. 디스크 포맷처럼 "바이트 한 칸도 틀리면 안 되는" 곳에 딱 맞는 안전장치입니다.

설계 ③ — Direct I/O와 페이지 정렬 버퍼

Direct I/O를 쓰려면 버퍼가 4096바이트 경계에 정렬돼야 합니다. 평범한 Vec<u8>은 그 보장이 없어, EntropyVerify는 OS별로 정렬 메모리를 직접 할당하는 AlignedBuffer를 만들었습니다 — 윈도우는 VirtualAlloc, 리눅스는 posix_memalign. 그리고 Deref<Target=[u8]>를 구현해, 쓸 때는 보통 슬라이스처럼 다루게 했습니다.

설계 ④ — 비동기 I/O 엔진: io_uring과 폴백, 큐depth 파이프라인

리눅스 엔진은 io_uring으로 "쓰기/읽기 요청을 제출(submit)하고, 완료(completion)를 나중에 회수"하는 구조입니다. 슬롯(버퍼+상태) 풀을 만들어 큐 깊이(QD)만큼 동시에 띄웁니다. io_uring 초기화가 실패하면 조용히 pread/pwrite 동기 모드로 폴백합니다 — 구형 커널 호환.

// engine/io/linux.rs — io_uring 초기화와 폴백
let inner = match io_uring::IoUring::builder().build(queue_depth) {
    Ok(ring) => EngineInner::IoUring(ring),
    Err(e)  => { eprintln!("io_uring 실패({}), 동기 I/O로 폴백", e);
                 EngineInner::Synchronous }
};

검증 단계의 파이프라이닝이 특히 교과서적입니다 — 먼저 QD개 읽기를 미리 제출해 두고, 완료가 하나 돌아올 때마다 그 블록을 검증하고 즉시 다음 읽기를 제출합니다. 그래서 디스크는 항상 "할 일이 가득"이라 쉬지 않습니다.

설계 ⑤ — 무잠금 동시성: 원자적 카운터 + 채널 + Condvar

워커들이 1초에 수만 블록을 쓰는데, 진행률 표시를 위해 매번 락을 잡으면 그 자체가 병목입니다. EntropyVerify는 락을 거의 안 씁니다:

// 워커는 그냥 더한다 — 잠금 없음
cfg.metrics.bytes_written.fetch_add(block_size, Ordering::Relaxed);
// TUI는 그냥 읽는다 — 50ms마다 처리량 환산
let delta = current.saturating_sub(last);
self.current_throughput = delta as f64 / elapsed;

설계 ⑥ — 안전장치: '시스템 드라이브를 절대 안 건드린다'

파괴적 도구이므로 다중 가드레일을 둡니다. 대상이 OS 루트 파티션(C:\·/)이면 거부, 리눅스의 /boot·/etc·/usr·/var·스왑 같은 임계 마운트도 차단, 그리고 실제로 쓰기 전 센티넬 파일(.entropy_verify_sentinel)을 만들었다 지워 쓰기 권한을 능동 확인합니다. 디스크는 100MiB 안전 여유를 남겨 100%까지 채우지 않습니다.

5디렉토리 구조 해부

"src/ 하나에 26개 모듈. 역할별로 폴더가 깔끔히 갈려 있어, 폴더 이름만 봐도 '암호·엔진·I/O·동시성·안전·UI'의 부품 목록이 보인다."

최상위 한눈에

26개 모듈을 역할로 묶어 보기

가장 큰 파일이 말해 주는 것

코어 로직에서 engine/io/windows.rs(369)·linux.rs(303)가 가장 큰 건, "이 프로젝트의 진짜 난이도는 암호가 아니라 OS별 비동기 I/O에 있다"는 뜻입니다(암호는 라이브러리가 해 주지만, IOCP·io_uring·정렬·DMA는 직접 다뤄야 함). main.rs(412)·app.rs(368)가 큰 건 단계 조율과 상태/메트릭 관리가 그만큼 촘촘하다는 뜻이고, tui/(660여 줄)가 큰 건 "보기 좋은 실시간 대시보드"에 생각보다 코드가 많이 든다는 현실을 보여 줍니다.

6학습 포인트 (기술별 — 배울 것 + 실습 아이디어)

"한 레포 안에 대칭암호·해시·Direct I/O·비동기 커널 API·무잠금 동시성·제로카피·Rust unsafe가 전부 실물로 들어 있다."

① 대칭암호 CTR 모드 + 하드웨어 가속(AES-NI)

배울 것: 블록 암호(AES)를 CTR 모드로 돌려 스트림 암호(=난수 생성기)로 쓰는 핵심 발상, 논스/카운터 설계, "0에 XOR하면 키스트림이 그대로 나온다"는 트릭. 그리고 +aes 타깃 피처로 AES-NI를 켜는 법과 그 대가(구형 CPU 비호환).

실습: 파이썬 cryptography나 Rust aes/ctr로 "카운터를 1씩 올리며 16바이트씩 암호화"해 난수 1MB를 만들고, gzip으로 압축이 거의 안 되는지 확인 = "압축 불가능 데이터"를 직접 체감.

② 무결성 해시 — BLAKE3

배울 것: 데이터 손상을 잡는 체크섬/해시의 역할, BLAKE3가 왜 빠른지(트리 구조 + SIMD 벡터화), "보안 비교가 아니니 상수시간 비교가 필요 없다"는 실용적 판단(hasher.rs 주석).

실습: 1MB 데이터의 BLAKE3 해시를 구한 뒤 한 바이트만 뒤집어 다시 해시 → 완전히 달라지는 걸 확인(쇄도 효과). verify_block이 손상을 잡는 원리와 동일.

③ Direct I/O + 페이지 정렬 버퍼

배울 것: OS 페이지 캐시가 벤치마크를 어떻게 속이는지, O_DIRECT/FILE_FLAG_NO_BUFFERING으로 그걸 우회하는 법, 그리고 그 대가인 정렬 요구를 posix_memalign/VirtualAlloc로 푸는 법. RAII로 raw 포인터를 안전하게 감싸는 AlignedBuffer 패턴.

실습: 리눅스에서 같은 파일을 일반 쓰기 vs O_DIRECT 쓰기로 각각 측정해 속도 차이를 비교. 정렬 안 된 버퍼로 O_DIRECT 쓰기를 시도해 EINVAL 에러를 직접 만나 보기.

④ 비동기 I/O — io_uring / IOCP + 큐depth 파이프라인

배울 것: "제출하고 나중에 완료를 회수"하는 비동기 모델, SQ/CQ 링과 user_data로 완료를 슬롯에 되짚는 법, 큐를 항상 가득 채우는 파이프라이닝(검증 루프가 본보기), 그리고 우아한 폴백(구형 커널엔 동기 pread/pwrite).

실습: io-uring 크레이트로 파일 하나를 QD4로 읽어 보기 — read 4개 제출 → 완료 회수 → 또 제출. "큐 깊이를 1로 줄이면 느려지는가"를 측정해 NVMe 병렬성을 체감.

⑤ 무잠금 동시성 — Atomics · 채널 · Condvar · 코어 피닝

배울 것: 핫패스에서 락을 피하는 법 — AtomicU64::fetch_add(Relaxed)로 카운터를 공유하고, crossbeam 채널로 이벤트를 흘리고, Condvar로 일시정지, AtomicBool로 중단. 그리고 core_affinity로 스레드를 코어에 고정해 캐시 지역성을 살리는 법.

실습: 스레드 4개가 공유 카운터를 1억 번 증가시킬 때 Mutex vs AtomicU64의 속도를 비교. core_for_worker처럼 "코어 0은 비우고 1..N에 배정"하는 라운드로빈을 짜 보기.

⑥ 제로카피 직렬화 — bytemuck · repr(C) · 컴파일타임 단언

배울 것: 구조체를 복사 없이 바이트로 보고 되돌리는 bytemuck::Pod, 메모리 레이아웃을 고정하는 #[repr(C)], 그리고 const _: () = assert!(size_of::<T>() == N)로 디스크 포맷 크기를 컴파일에 못박는 기법.

실습: #[repr(C)] 구조체를 만들고 bytemuck::bytes_of로 바이트를 출력해 필드가 어디에 놓이는지(패딩 포함) 확인. 필드 하나를 키워 컴파일타임 단언이 깨지는 걸 직접 보기.

⑦ Rust 시스템 프로그래밍 — unsafe · FFI · Drop · cargo 프로파일

배울 것: libc·windows-sys로 OS 시스템콜 직접 호출(FFI), raw 포인터를 Drop으로 안전하게 해제, unsafe impl Send/Sync의 의미와 책임, 그리고 lto·codegen-units=1·panic="abort" 같은 릴리스 최적화 다이얼.

실습: libc::posix_memalign으로 정렬 메모리를 할당했다가 Drop에서 free하는 작은 래퍼를 만들어 보기. panic="abort" 유무로 바이너리 크기가 어떻게 변하는지 비교.

⑧ 터미널 UI(TUI) 설계 — ratatui

배울 것: ratatui로 실시간 대시보드를 그리는 법 — 처리량 스파크라인, 진행바, ETA, 그리고 UI 스레드와 워커 스레드의 분리(코어 0 전용). 50ms 샘플링으로 떨림(jitter)을 줄이는 처리량 계산도.

실습: ratatui로 "1초에 한 번 난수 값을 스파크라인에 밀어넣는" 미니 대시보드를 만들어 보기. app.rs의 update_metrics처럼 "최근 120 샘플만 유지"하는 링버퍼를 구현.

7하드웨어 / 시스템 요구사항

"클라우드·GPU·DB·네트워크 전부 불필요. 대신 'AES-NI 있는 x86_64 CPU'와 '검사할 빈 드라이브'가 필수다."

8직접 해볼 수 있는 실습 과제

"빌드해서 USB 검사 → CTR 난수 직접 만들기 → BLAKE3로 손상 잡기 → 비동기 I/O 맛보기 → 미니 H2testw 만들기."

9관련 기술 심화 학습 로드맵 (6주 플랜)

"Rust 시스템 기초에서 출발해 암호·해시·Direct I/O·비동기 커널 API·무잠금 동시성까지, EntropyVerify를 길잡이 삼아."

10핵심 키워드 사전

"이 문서와 저장소에서 반복되는 시스템·암호·I/O 용어를 한곳에 모았다."

11참고 링크

• GitHub 저장소 — github.com/blamie/EntropyVerify
• README — 기능·블록 포맷·사용법 (README.md)
• TrendShift 페이지 — trendshift.io/repositories/62143
• AES-CTR(카운터 모드) — Block cipher mode of operation · BLAKE3 — BLAKE3-team/BLAKE3
• io_uring 입문 — Lord of the io_uring · io-uring 크레이트 — docs.rs/io-uring
• ratatui(TUI) — ratatui.rs · bytemuck — docs.rs/bytemuck · H2testw 배경 — 가짜 USB 용량