MZ COMPANY

Direwolf 랜섬웨어 분석 보고서

geonwoo9643 — Mon, 9 Feb 2026 19:31:59 +0900

1. 개요 (Overview)

1.1 분석 배경

Direwolf 랜섬웨어는 2025년 5월 처음 발견된 Golang 기반 폐쇄형(Closed-Group) 랜섬웨어로, Curve25519 기반 Diffie-Hellman 키 교환 및 ChaCha20 스트림 암호화를 통해 파일을 암호화합니다.
파일 확장자는 .direwolf로 변경되며, 데이터 암호화 + 유출 협박(이중 갈취, double extortion)을 수행합니다.

1.2 핵심 요약

암호화 체인 : ECDH (Curve25519) + SHA-256 (2회) + ChaCha20
키 생성 : 파일별 독립적인 임시 ECDH 키쌍 (RtlGenRandom)
최적화 : 1MB 초과 파일은 첫 1MB만 암호화
푸터 구조 : 38바이트 (임시 공개키 32B + 시그니처 6B)

암호화 메커니즘

Curve25519 기반 ECDH로 파일별 공유 비밀 생성
공유 비밀 → SHA-256 해시 → 세션 키 도출
도출된 세션 키로 ChaCha20 스트림 암호화 수행

암호화 워크플로우

// Step 1: 임시 ECDH 키쌍 생성 (파일별)
temp_privkey = RtlGenRandom(32 bytes)
temp_pubkey = Curve25519.ScalarBaseMult(temp_privkey)

// Step 2: 공유 비밀 생성
shared_secret = Curve25519.ScalarMult(temp_privkey, attacker_pubkey)

// Step 3: 키 파생 (이중 SHA-256)
hash1 = SHA256(shared_secret)          // ChaCha20 키
hash2 = SHA256(hash1)                  // Nonce 추출용

chacha20_key = hash1[0:32]
chacha20_nonce = hash2[10:22]          // 12바이트

// Step 4: 파일 암호화
ciphertext = ChaCha20(plaintext, chacha20_key, chacha20_nonce)

// Step 5: 메타데이터 추가
footer = temp_pubkey (32B) + signature (6B: 0xABBCCDDEEFF0)

2. 식별 정보 (Identification)

항목	값
Malware Family	Direwolf Ransomware
Filetype	PE64 (Windows 64-bit Executable, Golang)
Hash (SHA256)	7f877830ebafb0b809b96bac7baf4435e235ab7835f695006ff779e6178c3638
Hash (MD5)	bc6912c853be5907438b4978f6c49e43
Size	2,096,128 bytes (0x1ffc00)
Extension	.direwolf
Target	Windows 기반 시스템
Ransom Note	README_TO_DECRYPT.txt

2.1 패킹 분석 (Packing Analysis)

항목	값
Packer	UPX 3.96 (Ultimate Packer for eXecutables)
Original Size	~6.2 MB (언패킹 전 추정)
Packed Size	2,096,128 bytes (0x1ffc00)
압축률	약 66.2%
Entropy	7.4+ (높은 엔트로피 - 패킹 지표)

2.1.1 UPX 탐지 시그니처

- PE 섹션명 : UPX0, UPX1

- Import Table : 최소화됨

- Entry Point : UPX stub

2.1.2 언패킹 절차

1. UPX 탐지 : 'upx -t sample.exe'

2. 자동 언패킹 : 'upx -d sample.exe -o unpacked.exe'

3. IDA 분석 : 언패킹된 바이너리 로드

2.2 최초 실행 검사

Mutex : Global\direwolfAppMutex
탐지 마커 파일 : C:\runfinish.exe (이미 암호화된 시스템을 체크)
⇒ 둘 중 하나가 존재하면 자기 삭제 + 종료.

3. 분석 환경 및 도구 (Tools)

구분	도구명 (Tool)	용도 (Purpose)
정적 분석	IDA Pro	Golang 바이너리 디컴파일 및 암호화 로직 분석
동적 분석	API Monitor	RtlGenRandom API 후킹 및 키 추출
행위 분석	Process Monitor	파일 I/O 및 암호화 행위 추적
암호 분석	Python + cryptography	ChaCha20 복호화 스크립트 개발
라이브러리	golang.org/x/crypto	Curve25519, ChaCha20 구현 확인

4. 암호화 기술 분석 (Technical Analysis)

4.1 전체 암호화 워크플로우

[실행 단계]

1. 초기화
   - Windows CSP 획득
   - RtlGenRandom 초기화
   - 공격자 공개키 로드 (0x5E12E0)
   ↓

2. 파일 탐색
   - 재귀적 디렉터리 스캔
   - .direwolf, .exe, .dll 제외
   - 고루틴으로 병렬 처리
   ↓

3. 파일별 암호화
   [Step 1: 임시 키쌍 생성]
   temp_privkey = RtlGenRandom(32 bytes)
   temp_pubkey = Curve25519
   ↓
   
   [Step 2: ECDH 공유 비밀]
   shared_secret = Curve25519.ScalarMult(temp_privkey, attacker_pubkey)
   ↓
   
   [Step 3: 키 파생]
   hash1 = SHA256(shared_secret)
   hash2 = SHA256(hash1)
   chacha20_key = hash1[0:32]
   chacha20_nonce = hash2[10:22]
   ↓
   
   [Step 4: ChaCha20 암호화]
   if file_size > 1MB:
       encrypt_size = 1MB
   else:
       encrypt_size = file_size
   
   ciphertext = ChaCha20(plaintext, chacha20_key, chacha20_nonce)
   ↓
   
   [Step 5: 푸터 추가]
   footer = temp_pubkey (32B) + signature (0xABBCCDDEEFF0, 6B)
   ↓

4. 파일명 변경
   - 원본.확장자 → 원본.확장자.direwolf
   - README_TO_DECRYPT.txt 생성

4.2 키 생성 및 관리 (Key Generation)

4.2.1 임시 키쌍 생성 (Per-File)

v185 = runtime_makeslice(&RTYPE_uint8, 32, 32, ...);
io_ReadAtLeast(qword_5FDF30, qword_5FDF38, v185, 32, 32, 32, ...);
// → RtlGenRandom으로 32바이트 생성 (임시 개인키)

특징:

Windows RtlGenRandom (SystemFunction036) API 사용
CSPRNG (Cryptographically Secure PRNG)
각 파일마다 독립적인 32바이트 개인키

4.2.2 공격자 공개키

// 임시 공개키 생성
golang_org_x_crypto_curve25519_scalarBaseMult(
    v176,           // output: 임시 공개키 (32 bytes)
    v177,           // input: 임시 개인키 (32 bytes)
    ...
);

// 공유 비밀 생성
golang_org_x_crypto_curve25519_scalarMult(
    v174,           // output: 공유 비밀 (32 bytes)
    v177,           // input: 임시 개인키 (32 bytes)
    &unk_5E12E0,    // input: 공격자 공개키 (32 bytes)
    ...
);

수학적 원리:

G: Curve25519 생성점

임시 공개키 = G × 임시_개인키
공유 비밀 = 공격자_공개키 × 임시_개인키
= (G × 공격자_개인키) × 임시_개인키
= G × (공격자_개인키 × 임시_개인키)

4.4 키 파생 (Key Derivation)

4.4.1 이중 SHA-256

// 첫 번째 SHA-256
crypto_sha256_Sum256(v174, 32, 32, ...);  // input: 공유 비밀
*(_OWORD *)v179 = v120;                    // output: hash1

// 두 번째 SHA-256
crypto_sha256_Sum256(v179, 32, 32, ...);  // input: hash1
v178[0] = v121;                            // output: hash2
v178[1] = v146;

키 파생 과정:

hash1 = SHA256(shared_secret)      # 32 bytes → ChaCha20 Key
hash2 = SHA256(hash1)               # 32 bytes → Nonce 추출용

chacha20_key = hash1[0:32]          # 전체 32바이트
chacha20_nonce = hash2[10:22]       # 오프셋 10부터 12바이트

왜 두 번 해시하는가?

키 분리 (Key Separation) : 암호화 키와 Nonce를 독립적으로 파생
추가 엔트로피 : 보안성 강화
HKDF 대체 : 간단한 구현

4.5 ChaCha20 암호화

4.5.1 ChaCha20 초기화

golang_org_x_crypto_chacha20_newUnauthenticatedCipher(
    &v181,              // cipher 객체
    v179,               // 키: hash1 (32 bytes)
    32,
    32,
    v178 + 10,          // Nonce: hash2[10:22] (12 bytes)
    12,
    ...
);

파라미터:
Algorithm: ChaCha20 (20 rounds)
Key Size:  256 bits (32 bytes)
Nonce Size: 96 bits (12 bytes)
Counter:   32 bits (4 bytes, 초기값 0)

4.5.2 파일 크기 기반 최적화

v76 = v172;                    // v172 = 원본 파일 크기
if (v172 > 0x100000)          // 1MB = 1,048,576 bytes
    v76 = 0x100000;           // 1MB로 제한
v171 = v76;                   // 실제 암호화 크기

파일 크기	암호화 범위
≤ 1MB	전체 파일
> 1MB	첫 1MB만

4.6 파일 처리 아키텍처

4.6.1 암호화된 파일 구조

영역	크기	설명
암호화된 데이터	원본 크기 (max 1MB)	ChaCha20으로 암호화
Footer (38 bytes)
└─ 임시 공개키	32 bytes	복호화 시 필요
└─ 시그니처	6 bytes	0xABBCCDDEEFF0 (식별용)

4.6.2 메타데이터 추가

// 1. 임시 공개키 쓰기
os__ptr_File_WriteAt(
    v183,           // file handle
    v176,           // 임시 공개키 (32 bytes)
    32, 32,
    v172,           // offset: 파일 크기
    ...
);

// 2. 시그니처 쓰기
v169 = -556942165;  // 0xDECDBCAB (LE) → 0xABBCCDDE
v170 = -3857;       // 0xF0EF (LE) → 0xEFF0

os__ptr_File_WriteAt(
    v183,
    &v169,          // 시그니처 (6 bytes)
    6, 6,
    v172 + 32,      // offset: 파일 크기 + 32
    ...
);

4.7 정적 분석

runtime.main 함수

nanotime 초기화 (프로그램 시작 시간 기록)

런타임 초기화

가비지 컬렉터 활성화

main.main 함수 호출 (랜섬웨어 실행 시작점)

프로그램 종료 전 정리 작업

프로세스 종료

main.main 함수

명령줄 인자 파싱 (-p 옵션 : 프로세스 경로)

중복 실행 체크

완료 마커 파일 존재 여부 확인 (C:\BGDKecuqlc2d9akd.exe)

뮤텍스 열기 시도 (Global\BGDKecuqlc2d9akd)

고루틴 시작

Close_Service : 백업/보안 서비스 종료
Close_Log : 로그 서비스 종료
Clear_Recover : 섀도우 카피/백업 삭제
Close_Process : DB/백업 프로세스 종료
main.main.func1 -> TraverseDisk : 디스크 순회 및 암호화
main.main.func2 : 암호화 진행 상황 모니터링 - 주기적 로깅

2초 대기 (서비스 종료 시간 확보)

WaitGroup 생성 (병렬 암호화 동기화용)

시스템 강제 재부팅 (10초 후)

랜섬웨어 실행 파일 삭제 (3초 후)

뮤텍스 해제

Close_Service 함수 (백업/보안 서비스 종료)

Close_Log 함수 (로그 서비스 종료)

Clear_Recover 함수 (섀도우 카피/백업 삭제)

Close_Process 함수 (DB/백업 프로세스 종료)

main.main.func1 함수 (Traverse_Disk 함수 호출)

TraverseDisk 함수 (디스크 순회 및 암호화)

main.Traverse_Files.func1 함수 (파일/디렉터리 방문)

암호화 제외

랜섬노트 내용

Check_Pass 함수 (암호화 제외 확장자 필터링)

main.main.func2 함수 (암호화 진행 상황 모니터링 - 주기적 로깅)

main.main.func3 함수 (암호화 함수 호출)

encryptFile (파일 암호화)

푸터 시그니처 생성

RtlGenRandom 호출 (32바이트 임시 개인키 생성)

Curve25519 연산 (G * 임시 개인키) -> 32바이트 임시 공개키 생성

Curve25519 연산 (임시 개인키, 공격자 공개키) -> ECDH 공유 비밀 생성

공격자 Curve25519 공개키 (32바이트)

.direwolf 확장자 추가

파일 열기 (쓰기 권한)

SHA-256 Hash (ECDH 공유 비밀) -> ChaCha20 암호화 키 (32바이트)

SHA-256 Hash (ChaCha20 암호화 키) -> ChaCha20 Nonce 추출용 (32바이트)

ChaCha20 스트림 암호 초기화 (32바이트 키, 12바이트 Nonce)

파일 크기 검사 (1MB 초과 시, 첫 1MB만 암호화) -> 부분 암호화

ChaCha20 KeyStream XOR 연산 (파일 데이터 암호화)

푸터 쓰기 (임시 공개키 32바이트 + 시그니처 6바이트)

5. 복호화 기술 분석 (Decryption Strategy)

5.1 복호화 가능성 분석

5.1.1 복호화 가능 조건

요소	획득 방법
공격자 공개키	정적 분석
임시 개인키 (파일별)	RtlGenRandom API 후킹
암호화 알고리즘	정적 분석

5.1.2 복호화 가능 시나리오

시나리오 1: RtlGenRandom 후킹 (권장)
───────────────────────────
방법: 암호화 진행 중 API Monitor로 32바이트 페이로드 캡처

시나리오 2: 메모리 덤프
───────────────────────────
방법: 암호화 실행 중 프로세스 메모리 덤프
대상: RtlGenRandom 호출 직후 32바이트 패턴

시나리오 3: 브루트포스
───────────────────────────
방법: 후킹 로그의 모든 32바이트 후보 시도
시간 복잡도: O(n), n = RtlGenRandom 호출 횟수

5.2 복호화 체인

5.2.1 전체 복호화 프로세스

[입력 데이터]
1. 암호화된 파일 (.direwolf)
2. RtlGenRandom 후킹 로그 (JSON)
3. 공격자 공개키

↓

[Step 1: 푸터 파싱]
ciphertext = file[:-38]
temp_pubkey = file[-38:-6]
signature = file[-6:]

↓

[Step 2: ECDH 공유 비밀 재생성]
for each candidate_privkey in hooking_log:
    shared_secret = Curve25519.ScalarMult(candidate_privkey, attacker_pubkey)
    
↓

[Step 3: 키 파생]
hash1 = SHA256(shared_secret)
hash2 = SHA256(hash1)
chacha20_key = hash1[0:32]
chacha20_nonce = hash2[10:22]

↓

[Step 4: ChaCha20 복호화]
plaintext = ChaCha20(ciphertext, chacha20_key, chacha20_nonce)

↓

[Step 5: 파일 시그니처 검증]
if plaintext.startswith(JPEG_MAGIC):  # 0xFFD8FF
    extension = '.jpg'
elif plaintext.startswith(PDF_MAGIC):  # 0x25504446
    extension = '.pdf'

5.3 자동화 복호화 스크립트

5.3.1 핵심 복호화 로직

import json
import hashlib
from cryptography.hazmat.primitives.asymmetric import x25519
from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat

ONE_MB = 0x100000  # 1MB 기준 (부분 암호화 구간)

def decrypt_direwolf(encrypted_file, hooking_json, attacker_pubkey):
    """
    Direwolf 복호화
    1) footer에서 temp_pubkey 추출
    2) RtlGenRandom(32B) 후보 수집
    3) pubkey 일치하는 키만 사용
    4) ChaCha20 복호화 (부분 암호화 반영)
    """

    # 파일 읽기 및 footer 분리
    with open(encrypted_file, 'rb') as f:
        data = f.read()

    if len(data) < 38:
        return None

    body = data[:-38]
    temp_pubkey_from_file = data[-38:-6]
    signature = data[-6:]

    # 시그니처 확인
    if signature != bytes.fromhex("abbccddeeff0"):
        return None

    # 부분 암호화 길이 계산 (앞 1MB만 암호화된 경우 대비)
    enc_len = min(len(body), ONE_MB)

    # Hooking 로그에서 32바이트 난수 후보 수집
    with open(hooking_json, 'r') as f:
        log = json.load(f)

    candidates = [
        e.get('payload_hex')
        for e in log.get('events', [])
        if e.get('api') == 'RtlGenRandom'
        and e.get('length_bytes') == 32
        and e.get('payload_hex')
    ]

    attacker_pk = x25519.X25519PublicKey.from_public_bytes(
        bytes.fromhex(attacker_pubkey)
    )

    for temp_privkey_hex in candidates:
        try:
            temp_sk = x25519.X25519PrivateKey.from_private_bytes(
                bytes.fromhex(temp_privkey_hex)
            )

            # footer의 temp_pubkey와 일치하는 후보만 사용
            cand_pub = temp_sk.public_key().public_bytes(
                Encoding.Raw, PublicFormat.Raw
            )
            if cand_pub != temp_pubkey_from_file:
                continue

            # ECDH → 키/nonce 파생
            shared_secret = temp_sk.exchange(attacker_pk)
            key = hashlib.sha256(shared_secret).digest()
            nonce = hashlib.sha256(key).digest()[10:22]

            # 앞 enc_len만 복호화 (부분 암호화 대응)
            dec_head = chacha20_decrypt(key, nonce, body[:enc_len])
            plaintext = dec_head + body[enc_len:]

            # 복호화 성공 확인
            if check_file_signature(plaintext):
                return plaintext

        except (ValueError, TypeError):
            continue

    return None

5.3.2 ChaCha20 구현

def chacha20_block(key, counter, nonce):
    """ChaCha20 블록 생성"""
    constants = b"expand 32-byte k"
    
    state = [0] * 16
    state[0:4] = struct.unpack("<4I", constants)
    state[4:12] = struct.unpack("<8I", key)
    state[12] = counter
    state[13:16] = struct.unpack("<3I", nonce)
    
    working = state[:]
    
    # 20 rounds
    for _ in range(10):
        # Column rounds
        quarter_round(working, 0, 4, 8, 12)
        quarter_round(working, 1, 5, 9, 13)
        quarter_round(working, 2, 6, 10, 14)
        quarter_round(working, 3, 7, 11, 15)
        # Diagonal rounds
        quarter_round(working, 0, 5, 10, 15)
        quarter_round(working, 1, 6, 11, 12)
        quarter_round(working, 2, 7, 8, 13)
        quarter_round(working, 3, 4, 9, 14)
    
    output = [(working[i] + state[i]) & 0xffffffff for i in range(16)]
    return b"".join(struct.pack("<I", w) for w in output)

5.4 무결성 검증

5.4.1 파일 시그니처 테이블

파일 유형	매직 넘버 (Hex)
JPEG	FF D8 FF E0/E1/DB
PNG	89 50 4E 47 0D 0A 1A 0A
PDF	25 50 44 46
ZIP/DOCX	50 4B 03 04
EXE	4D 5A

5.4.2 검증 로직

def check_file_signature(data):
    """복호화된 데이터 검증"""
    signatures = {
        b'\\xFF\\xD8\\xFF': ".jpg",
        b'\\x89PNG': ".png",
        b'%PDF': ".pdf",
        b'PK\\x03\\x04': ".zip",
        b'MZ': ".exe"
    }
    
    for sig, ext in signatures.items():
        if data.startswith(sig):
            return ext
    
    return None

6. 요약 및 결론 (Conclusion)

6.1 최종 평가

Direwolf 랜섬웨어는 ECDH (Curve25519) + SHA-256 (2회) + ChaCha20을 사용하는 현대적인 하이브리드 암호화 구조를 가지고 있습니다. Golang으로 개발되어 크로스 플랫폼 지원이 가능하며, 파일별 독립 키 생성과 1MB 임계값 기반 부분 암호화로 성능을 최적화했습니다. RtlGenRandom API 후킹을 통해 임시 개인키를 획득하면 완전한 복호화가 가능합니다. 테스트 결과 모든 파일에서 매직 바이트가 검증되었으며, 파일 무결성이 확인되었습니다.

6.2 대응 가이드

6.2.1 예방적 조치

API 모니터링

RtlGenRandom 과도한 호출 탐지
32바이트 요청 패턴 감지
실시간 API 후킹 로깅

행위 기반 탐지

대량 파일 접근 패턴
.direwolf 확장자 추가 차단
고루틴 생성 패턴 탐지

네트워크 방어

Tor 네트워크 접근 차단
C&C 통신 탐지
DNS 필터링

백업 전략

실시간 오프라인 백업
VSS (Volume Shadow Copy) 보호
Immutable 백업 스토리지

6.2.2 사후 대응

초동 조치
- 감염 시스템 격리
- 즉시 RtlGenRandom API 후킹 시작 (시스템 종료 금지!)
- 프로세스 메모리 덤프
키 복구
- API Monitor 로그에서 32바이트 후보 추출
- 메모리 덤프 분석 (높은 엔트로피 32바이트 패턴)
복호화 수행
- 자동화 스크립트 실행
- 브루트포스 (후보 키 시도)
- 매직 바이트 검증
시스템 복구
- 복호화 성공 후 시스템 재구축
- 초기 침투 경로 분석
- 보안 패치 적용

6.3 기술적 특징 요약

항목	세부 내용
키 교환	ECDH (Curve25519, 256-bit)
키 파생	SHA-256 (2회)
대칭 암호	ChaCha20 (256-bit key, 96-bit nonce)
키 생성	RtlGenRandom (CSPRNG)
최적화	1MB 초과 시 부분 암호화
푸터	38 bytes (임시 공개키 + 시그니처)
확장자	.direwolf
랜섬 노트	README_TO_DECRYPT.txt
언어	Golang 1.x

6.4 결론

Direwolf 랜섬웨어는 강력한 암호학적 설계를 가지고 있으나, RtlGenRandom API가 노출된 취약점으로 인해 동적 분석을 통한 복호화가 가능합니다. 공격자의 공개키가 바이너리에 하드코딩되어 있고, 파일별 임시 개인키가 Windows API를 통해 생성되므로 API 후킹으로 완전한 키 체인을 복구할 수 있습니다.

암호학 알고리즘 : Curve25519 + ChaCha20
구현 취약점 : RtlGenRandom 후킹 가능

부록

YARA 룰

1) Direwolf 랜섬웨어 바이너리 탐지(PE)

rule Ransomware_Direwolf_Golang_UPX_AttackerPubkey
{
  strings:
    // attacker Curve25519 pubkey (32B) from report
    $attacker_pk = { c5 9e 3a d3 3a 79 dd 6e 0f 1b f2 28 63 6b a4 76 ba ff 99 3e 82 d1 1c 7e 51 f2 71 2c fd 23 0c 1f }

    // common artifacts
    $ext  = ".direwolf" ascii wide
    $note = "README_TO_DECRYPT.txt" ascii wide

    // UPX section names are often present in packed samples
    $upx0 = "UPX0" ascii
    $upx1 = "UPX1" ascii

  condition:
    uint16(0) == 0x5A4D and          // MZ
    filesize < 15MB and
    $attacker_pk and
    (1 of ($ext, $note)) and
    (1 of ($upx0, $upx1))
}

2) 암호화된 파일(.direwolf) 아티팩트 탐지 (footer 시그니처)

rule Ransomware_Direwolf_EncryptedFile_FooterSignature
{
  strings:
    $sig = { AB BC CD DE EF F0 }  // footer signature (6B)

  condition:
    filesize > 38 and
    $sig at (filesize - 6)
}

Mallox 랜섬웨어 분석 보고서

geonwoo9643 — Mon, 9 Feb 2026 04:07:40 +0900

1. 개요 (Overview)

1.1 분석 배경

Mallox 랜섬웨어는 2021년에 처음 등장한 RaaS(Ransomware-as-a-Service) 그룹으로, 초기에는 ChaCha20 기반 암호화를 사용했으나 최신 버전에서는 AES-256-GCM 기반 암호화 구조로 변경되었습니다. AES-128 키는 고정 하드코딩 값이 아니라 ECDH 결과에서 파생되는 세션 기반 키입니다. GCM Nonce 길이는 구현에 따라 달라질 수 있으며, 본 샘플에서는 8바이트를 사용했습니다. 암호화 체인은 다음과 같이 구성됩니다:

X25519(ECDH)를 통해 공유 비밀 생성
SHA-256을 통해 키 파생
파생된 키를 기반으로 AES-128-CTR 키 래핑 수행
파일 데이터 암호화에 사용되는 AES-256-GCM

1.2 핵심 요약

암호화 체인 : X25519 (ECDH) → SHA-256 (Key Derivation) → AES-128-CTR (per-file key wrapping) → AES-256-GCM (파일 암호화)
메모리 포렌식 : ECDH 결과 또는 SHA-256 파생 키를 메모리에서 확보해야 복호화 가능
푸터 구조 :
- 108 bytes 고정
- 40 bytes: AES-256 key + GCM nonce (AES-128-CTR로 암호화됨)
- 16 bytes: AES-CTR IV
- 기타 상수 및 매직

암호화 워크플로우

// Step 0: ECDH 기반 세션 키 도출
shared_secret = X25519(private_key, peer_public_key);
session_key = SHA256(shared_secret);     // 32 bytes
aes128_ctr_key = session_key[0:16];      // CTR wrapping key

// Step 1: ISAAC PRNG에서 per-file 난수 생성
v56 = isaac_extract(16);      // AES-128-CTR IV (16B)
v60 = isaac_extract(40);      // 32B AES-256 key + 8B GCM nonce

// Step 2: per-file key 래핑 (AES-128-CTR)
encrypted_metadata = AES128_CTR_Encrypt(v60, aes128_ctr_key, v56);

// Step 3: 파일 데이터 암호화 (AES-256-GCM)
file_ciphertext = AES256_GCM_Encrypt(file_data, key=v60[0:32], nonce=v60[32:40]);

// Step 4: Footer 구성
footer = magic + size + encrypted_metadata + v56 + const + const + magic2;

2. 식별 정보 (Identification)

항목	값
Malware Family	Mallox Ransom (TargetCompany)
Filetype	PE32+ (Windows 64-bit Executable)
Hash (SHA256)	06699c98ed2ef759b2434ac5777a2886b966c0ffa1c96c046f5cde77fe833784
Extension	.mallab
Target	Windows 기반 시스템
First Seen	June 2021
Ransom Note	"HOW TO RECOVER !!.TXT"

3. 분석 환경 및 도구 (Tools)

구분	도구명 (Tool)	용도 (Purpose)
정적 분석	IDA Pro	AES-GCM/GHASH 구현 루틴 및 암호화 로직 분석
동적 분석	WinDbg	메모리 덤프 및 암호화 키 추출
행위 분석	Process Monitor	파일 I/O 및 암호화 행위 추적
암호 분석	Python + Pycryptodome	AES-256-GCM 복호화 스크립트 개발
메모리 분석	메모리 포렌식	AES-128-CTR 키 추출

4. 암호화 기술 분석 (Technical Analysis)

4.1 전체 암호화 워크플로우

[실행 단계] 
1. 초기화 - X25519 키쌍 생성 (개인 키 32바이트) - 베이스 포인트 연산 수행 - ECDH shared secret 생성 - SHA-256(shared_secret) → 세션 키 도출 - 해당 세션 키를 AES-128-CTR key로 사용
↓ 
2. 파일 탐색 및 암호화 - 재귀적 디렉터리 탐색 - 파일 필터링 (.exe, .dll, .mallab 제외) - 파일별 ISAAC PRNG에서 랜덤 데이터 생성
↓ 
3. 파일별 암호화 수행 [ISAAC PRNG 출력] - v56 = 16바이트 (AES-128-CTR IV) - v60 = 40바이트 (AES-256 key 32B + GCM nonce 8B)
↓ 
[Step 1: AES-128-CTR로 v60 암호화] encrypted_metadata = AES128_CTR(v60, aes128_ctr_key, v56)
↓  
[Step 2: AES-256-GCM로 파일 암호화] ciphertext = AES256_GCM(file_data, v60[:32], v60[32:40])
↓ 
[Step 3: 푸터 구성 및 저장] footer = magic1(8B) + original_size(8B) + encrypted_metadata(40B) + v56(16B) + const1(16B) + const2(16B) + magic2(4B)
↓ Original Size : 파일 데이터 원본 길이 저장, 복호화 후 원본 길이만큼 잘라줘야 함
↓ Const1/Const2 : 실제로는 고정 상수 (의미 없는 자리 채움일 수 있음)
4. 파일명 변경 및 랜섬 노트 생성 - 원본.확장자 → 원본.확장자.mallab - HOW TO RECOVER !!.TXT 생성

4.2 키 생성 및 관리 (Key Generation)

4.2.1 하이브리드 암호화 구조

ISAAC PRNG 기반 per-file 키 생성

ISAAC PRNG (Indirection, Shift, Accumulate, Add, Count)

• 내부 상태: 2KB (256 × 32-bit words)
• 출력: 32-bit 정수 스트림
• 파일별 독립적인 난수 시퀀스 생성에 사용

Mallox는 ISAAC을 per-file AES-256 key 및
GCM nonce 생성에 사용한다.

※ ISAAC은 고속 PRNG이지만,
현대 CSPRNG(Cryptographically Secure PRNG)와
동일한 수준의 안전성이 보장되는 것은 아니다.

AES-128-CTR 키

용도: 푸터의 40바이트 메타데이터 암호화

특징: AES-128-CTR 키는 ECDH 결과에서 파생되며, 동일 감염 인스턴스에서 생성된 파일들에 대해 공통으로 사용될 수 있다.

중요: AES-128-CTR 키는 X25519(ECDH) 결과를 SHA-256으로 해시하여 동적으로 생성됩니다. 따라서 고정 마스터 키는 존재하지 않으며, 감염 인스턴스마다 키가 달라집니다.

4.2.2 키 체인 구조

원본 파일 
↓ 
[AES-256-GCM 암호화] 암호화된 파일 
↓ 
AES-256 키 (32바이트) + GCM nonce (8바이트) 
↓ 
[AES-128-CTR 암호화, master_key 사용] 암호화된 메타데이터 (40바이트, 푸터에 저장) 
↓ 
AES-128-CTR 키 (16바이트)

4.3 AES 암호화 알고리즘

4.3.1 AES-256-GCM 구조

알고리즘 특성
모드: GCM (Galois/Counter Mode)

키 길이: 32바이트 (256비트)

Nonce: 8바이트 (64비트)

인증: GHASH (Galois Hash)

GCM 모드 특징
CTR 암호화: 병렬 처리 가능

GHASH 인증: 데이터 무결성 보장

AEAD: Authenticated Encryption with Associated Data

4.3.2 AES-128-CTR 키 래핑

// AES-128-CTR
// 16바이트 IV: isaac_extract(16) 
// 16바이트, 파일별 독립 Mode: CTR (Counter Mode) 
// CTR 모드 동작 Counter = IV + 0 C[i] = P[i] ⊕ AES_Encrypt(Counter + i, Key) 
// 메타데이터 암호화 plaintext = AES_256_key (32B) + GCM_nonce (8B) 
// 40바이트 ciphertext = AES128_CTR_Encrypt(plaintext, master_key, IV)

4.4 파일 처리 아키텍처

4.4.1 암호화된 파일 구조

Mallox는 파일 끝에 108바이트 고정 크기 푸터를 추가합니다.

영역	크기	설명
암호화된 데이터	원본 크기	AES-256-GCM으로 암호화된 파일 내용
Footer (108 bytes)
└─ Offset 0-7	8 bytes	Magic: 0201020100000000
└─ Offset 8-15	8 bytes	원본 파일 크기 (Little-endian)
└─ Offset 16-55	40 bytes	암호화된 메타데이터 (AES-128-CTR)- AES-256 key (32B) + GCM nonce (8B)
└─ Offset 56-71	16 bytes	AES-128-CTR IV
└─ Offset 72-87	16 bytes	Const1 (고정값)
└─ Offset 88-103	16 bytes	Const2 (고정값)
└─ Offset 104-107	4 bytes	Magic: 00000000

4.4.2 실제 푸터 예시

Size: 49152 bytes (0x0000000000c00000) 
Encrypted Metadata: 
6047e0e6ed1e5281b41f855c68888f2e... // 40 bytes AES-CTR IV: 
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx // 16 bytes Const1: 
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx // 16 bytes Const2: 
00000000000000000000000000000000 // 16 bytes Magic2: 00000000

4.5 정적 분석

WinMain 함수

러시아/CIS 국가 언어 검사 (실행 제외)

뮤텍스 생성 (중복 실행 방지)

고성능 전원 모드 설정 (암호화 속도 최적화)

권한 상승

첫 번째 작업 스레드 생성 (복구 방지/섀도우 카피 삭제)

랜섬노트 내용

두 번째 작업 스레드 생성 (방어 도구 제거)

NtQueryObject API 동적 로딩

시스템 종료 차단

암호화 초기화 및 시작

명령줄 인자 파싱

옵션	의미	예시
-l	파일 잠금 목록	파일 리스트
-d	복호화 모드	복호화 실행
-p	경로 리스트 파일	paths.txt
-path	특정 경로 지정	C:\Users
-queue	숫자 파라미터	4 (스레드 개수)

난수 소스 수집 (QPC, ThreadID, PID, TSC)

난수 생성기 초기화 (CryptGenRandom)

Mersenne Twister 시드 설정 및 상태 배열 초기화

초기 상수 배열 초기화 (X25519 ECDH 2단계 파라미터용)

X25519 베이스포인트 및 추가 상수 초기화 (ECDH 키 파생용)

컴퓨터 이름 수집 (ID 생성용)

Windows 디렉터리 생성 시간 수집

볼륨 시리얼 번호 수집

시스템 정보 결합

CPU ID 수집

SHA-256 초기 해시값 설정

SHA-256 해시 (시스템 정보)

개인 키 생성 (32바이트)

X25519 ECDH 3단계 연산 (개인 키, 베이스 포인트)

SHA-256 초기 상수 재설정

SHA-256 (ECDH 결과) → 최종 마스터 키 생성 (32바이트)

최종 키 생성

볼륨 열거 및 마운트

FindFirstFileExW 지원 여부 테스트

고유 ID 생성 (랜섬노트용)

파일 암호화

I/O Completion 포트 생성 (멀티스레드 암호화)

워커 스레드 생성 (파일 암호화 처리)

모든 볼륨 열거

숨겨진 볼륨 마운트 (복구 방지)

모든 논리 드라이브 스캔

드라이브별 암호화 스레드 생성

디렉터리 재귀 탐색 및 암호화 대상 큐 추가

드라이브 타입 확인 (로컬/네트워크)

제외 디렉터리 검사

제외 디렉터리 목록

msocache, $windows.~ws, system volume information, intel, appdata, perflogs, programdata, 
google, application data, tor browser, boot, $windows.~bt, mozilla, boot, windows.old,
Windows Microsoft.NET, WindowsPowerShell, Windows NT, Windows, Common Files,
Microsoft Security Client, Internet Explorer, Reference, Assemblies, Windows Defender,
Microsoft ASP.NET, Core Runtime, Package, Store, Microsoft Help Viewer, Microsoft MPI,
Windows Kits, Microsoft.NET, Windows Mail, Microsoft Security Client, Package Store,
Microsoft Analysis Services, Windows Portable Devices, Windows Photo Viewer, Windows Sidebar

화이트리스트 확장자 검사

암호화 대상 확장자 목록

.msstyles, .icl, .idx, .avast, .rtp, .mallox, .sys, .nomedia, .dll, .hta, .cur, .lock, .cpl,
.Globeimposter-Alpha865qqz, .ics, .hlp, .com, .spl, .msi, .key, .mpa, .rom, .drv, .bat, .386,
.adv, .diangcab, .mod, .scr, .theme, .ocx, .prf, .cab, .diagcfg, .msu, .cmd, .ico, .msc, .ani,
.icns, .diagpkg, .deskthemepackm, .wpx, .msp, .bin, .themepack, .shs, .nls, .exe, .lnk, .ps1, 
.mallab

블랙리스트 파일명 검사

제외 파일 목록

desktop.ini, ntuser.dat, thumbs.db, iconcache.db, ntuser.ini, ntldr, bootfont.bin, 
ntuser.dat.log, bootsect.bak, boot.ini, autorun.inf, debugLog.txt, TargetInfo.txt

암호화 작업 큐에 추가

랜섬노트 생성

암호화 작업 큐 추가

랜섬노트 생성

마스터 키 메모리 삭제

네트워크 공유 스레드 강제 종료

감염 정보 수집 (HDD 사용 용량, 시스템 정보) 및 C2 전송 후, 로컬 백업

Http Request 함수

파일/디렉터리 존재 여부 확인

관리자 권한 체크

명령줄 재구성 (UAC 재실행 준비)

UAC 재실행 (권한 없을 경우)

에러 메시지 (”File not found OR Invalid argument”)

잘못된 인자 팝업으로 표시

5. 복호화 기술 분석 (Decryption Strategy)

5.1 복호화 가능성 분석

5.1.1 하이브리드 암호화 복호화 가능 원리

복호화를 위한 키 체인: 
1. ECDH shared secret
2. SHA-256 파생 세션 키 (AES-128-CTR 키)
3. AES-128-CTR로 푸터 복호화
4. per-file AES-256 key + nonce 획득
5. AES-256-GCM 복호화
추출 성공 요인: 
- AES-128-CTR 키는 모든 파일에 공통 사용
- 메모리 덤프에서 키 획득 가능 
- ISAAC PRNG 상태 복구 불필요 (푸터에 암호화된 형태로 저장)

5.1.2 복호화 가능 시나리오

시나리오 1: 메모리 포렌식
방법: 암호화 진행 중 메모리 덤프

대상: AES-128-CTR 키 (16바이트)

성공 확률: 높음 (랜섬웨어 프로세스 메모리에 상주)

시나리오 2: 바이너리 추출
방법: 랜섬웨어 바이너리 정적 분석

대상: ECDH 유도 값

성공 확률: 중간 (난독화 또는 동적 생성 가능)

5.2 AES-128 마스터 키 복구 메커니즘

5.2.1 메모리 포렌식 키 추출

// 메모리 덤프 파일 
// 키 검증 방법 
1. 테스트 파일의 푸터에서 암호화된 메타데이터 추출 
2. 추출한 키로 AES-128-CTR 복호화 시도 
3. 결과가 32바이트 + 8바이트 구조인지 확인 
4. 추출한 AES-256 키로 파일 복호화 
5. 매직 바이트 검증

5.3 자동화 복호화 스크립트 개발

5.3.1 복호화 체인

[ key.json ] 
↓ 
AES-128-CTR key 
↓ 
┌──────────────────────────────┐ 
│  footer encrypted_metadata   │ 
│         (40 bytes)           │ 
└──────────────────────────────┘ 
↓ 
AES-128-CTR 복호화 
↓ 
┌──────────────────────────────┐ 
│  AES-256 file key (32 bytes) │ 
│      GCM nonce (8 bytes)     │ 
└──────────────────────────────┘ 
↓ 
AES-256-GCM 
↓ 
[     원본 파일 데이터 복원      ]

5.3.2 핵심 복호화 로직

1. 키 로드

def load_keys(json_path): 
"""Load decryption keys from JSON file""" 
	with open(json_path, 'r') as f: 
keys = json.load(f) 
aes128_key = bytes.fromhex(keys['aes128_ctr_key']) 
if len(aes128_key) != 16: 
	raise ValueError(f"Invalid AES-128 key length") 
return aes128_key

2. 푸터 파싱

# 파일 끝 108바이트 읽기 
footer = data[-108:] 
ciphertext = data[:-108] 
# 푸터 구조 파싱 
magic1 = footer[0:8] 
original_size = struct.unpack('<Q', footer[8:16])[0] 
encrypted_metadata = footer[16:56] 
# 40 bytes 
aes_ctr_iv = footer[56:72] 
# 16 bytes 
const1 = footer[72:88] 
const2 = footer[88:104] 
magic2 = footer[104:108]

3. AES-128-CTR 복호화 (메타데이터 언래핑)

# AES-128-CTR 초기화 
ctr = Counter.new(128, initial_value=int.from_bytes(aes_ctr_iv, 'big')) 
cipher = AES.new(aes128_key, AES.MODE_CTR, counter=ctr) 
# 메타데이터 복호화 
decrypted_metadata = cipher.decrypt(encrypted_metadata) 
# AES-256 키와 GCM nonce 추출 
aes256_key = decrypted_metadata[:32] gcm_nonce = decrypted_metadata[32:40]

4. AES-256-GCM 복호화 (파일 데이터)

# AES-256-GCM 초기화 
cipher_text = AES.new(aes256_key, AES.MODE_GCM, nonce=gcm_nonce) 
# 태그 추출
ciphertext, tag = ciphertext[:-16], ciphertext[-16:]
# 파일 데이터 복호화 
plaintext = cipher.decrypt_and_verify(ciphertext, tag)
# 원본 크기로 자르기 
plaintext = plaintext[:original_size]

5.4 무결성 검증

5.4.1 매직 바이트 테이블

파일 유형	매직 넘버 (Hex)	설명
PNG	89 50 4E 47 0D 0A 1A 0A	PNG 이미지
JPG/JPEG	FF D8 FF E0/E1/DB	JPEG 이미지
PDF	25 50 44 46	PDF 문서
ZIP	50 4B 03 04	ZIP 압축 파일
DOCX/XLSX	50 4B 03 04	Office Open XML (ZIP 기반)

6. 요약 및 결론 (Conclusion)

6.1 최종 평가

Mallox 랜섬웨어 최신 버전은 AES-256-GCM + AES-128-CTR 하이브리드 암호화 구조를 가지고 있으며, ISAAC PRNG 기반 파일별 독립 키 생성을 통한 암호화를 구현합니다. 메모리 포렌식을 통해 ECDH 연산 결과 또는 SHA-256 파생 세션 키를 확보하여 AES-128-CTR 레이어를 해제하고, per-file AES-256-GCM 키를 추출하여 복호화에 성공했습니다. 4개 테스트 파일 모두 매직 바이트가 검증되었으며, 4개 테스트 파일 모두 매직 바이트/파일 포맷이 정상 복원됨을 확인하였다.

6.2 대응 가이드

6.2.1 예방적 조치

메모리 보호

AES-128-CTR 키 메모리 상주 차단
프로세스 메모리 실시간 모니터링
의심 프로세스 즉시 덤프

행위 기반 탐지

대량 파일 접근 패턴 탐지
.mallab 확장자 추가 차단
ISAAC PRNG 호출 패턴 탐지

네트워크 방어

RDP 접근 제한 및 MFA 적용
의심 PowerShell 실행 차단
C&C 통신 탐지

백업 전략

실시간 오프라인 백업
VSS 보호 솔루션
immutable 백업 스토리지

6.2.2 사후 대응

초동 조치 : 감염 발견 즉시 시스템 격리, 메모리 덤프 수행 (시스템 종료 금지!)
키 복구 : 메모리 포렌식으로 AES-128-CTR 키 추출 (패턴: 16바이트 높은 엔트로피)
복호화 수행 : 추출한 키로 자동화 스크립트 실행, 매직 바이트 검증
시스템 복구 : 복호화 성공 후 시스템 재구축, 초기 침투 경로 분석 및 패치

6.3 탐지 시그니처

탐지 요소	값 / 패턴
확장자	.mallab
푸터 Magic1	0x0201020100000000
메타데이터 길이	40 bytes
AES-CTR IV 길이	16 bytes
GCM Nonce 길이	8 bytes

6.4 초기 vs 최신 Mallox 차이

Mallox 랜섬웨어는 버전별로 암호화 구조가 진화해 왔다.

[초기 버전 (2021~2022)]
• 파일 암호화: ChaCha20
• 키 보호: ECDH + SHA-256
• 일부 버전은 AES-128-CTR을 key wrapping에 사용

[중기 버전]
• ChaCha20 유지
• AES-CTR 기반 키 래핑 구조 강화

[최신 버전 (v12 이후)]
• 파일 암호화: AES-256-GCM
• 키 보호: ECDH (X25519) + SHA-256
• per-file 키 생성: ISAAC PRNG
• AES-128-CTR 레이어로 파일 키 래핑

즉, Mallox는 단순 ChaCha 기반 랜섬웨어에서
AEAD(AES-GCM) 기반 고급 하이브리드 구조로
진화하였다.

6.4 결론

Mallox 랜섬웨어는 AES-256-GCM과 AES-128-CTR을 결합한 정교한 하이브리드 암호화 구조를 가지고 있으며, ISAAC PRNG를 통한 파일별 독립 키 생성을 구현합니다. 2021년 등장 이후 지속적으로 업그레이드되어 Mallox 최신 버전은 ECDH 기반 세션 키 파생 구조와 AES-256-GCM AEAD 암호화를 결합하여 기밀성(confidentiality)과 무결성(integrity)을 동시에 보장하는 구조를 채택하였다.

INC 랜섬웨어 분석 보고서

geonwoo9643 — Sun, 8 Feb 2026 21:27:19 +0900

1. 개요 (Overview)

1.1 분석 배경

INC 랜섬웨어는 2023년 7월에 처음 등장한 RaaS(Ransomware-as-a-Service) 운영 그룹으로, AES 대칭 암호화와 RSA 비대칭 암호화를 결합한 하이브리드 암호화 방식을 채택하고 있습니다. 부분 암호화(Intermittent Encryption)와 멀티스레딩 기법을 통해 고속 암호화를 구현하며, CVE-2023-3519(Citrix NetScaler) 취약점을 악용하여 초기 침투를 수행합니다. 본 보고서는 INC 랜섬웨어의 암호화 메커니즘을 정밀 분석하고, 키 복구 전략 및 복호화 가능성을 평가합니다.

1.2 핵심 요약

암호화 메커니즘

AES-256 대칭 암호화를 통한 파일별 고속 암호화
RSA-2048 비대칭 암호화로 AES 키 보호
부분 암호화(Intermittent Encryption) 기법으로 암호화 속도 극대화
파일별 독립적인 AES 키 생성 (CryptGenRandom API)

회피 기법

멀티스레딩 (CPU 코어 수 × 4 스레드)
VSS(Volume Shadow Copy) 삭제 시도
특정 파일/디렉터리 제외 (.msi, .exe, .dll, Windows, Program Files 등)
프린터 자동 랜섬 노트 출력

복호화 가능성

CryptGenRandom API 호출 시점의 파일별 AES 키를 API 후킹으로 실시간 캡처 시 완벽한 복호화 가능
공격자 RSA 개인키 없이는 복호화 불가능
본 분석에서 개발한 자동화 복호화 스크립트로 실증 검증 완료

2. 식별 정보 (Identification)

Malware Family: INC Ransom

Filetype: PE32 (Windows Executable)

Hash (SHA256): 834c5f094c4a2db0f520962341b108af685efd346e5b6622eb2331b3ffa09039

Extension: .INC

Target: Windows 기반 시스템 (Linux 변형 존재)

First Seen: July 2023

Ransom Note: INC-README.TXT, INC-README.HTML

3. 분석 환경 및 도구 (Tools)

구분	도구명 (Tool)	용도 (Purpose)
정적 분석	IDA Pro	AES/RSA 구현 루틴 및 암호화 로직 분석
동적 분석	CryptGenRandom API Hooking	실시간 AES 키 추출
행위 분석	Process Monitor	파일 I/O 및 암호화 행위 추적
암호 분석	Python	AES 복호화 스크립트 개발
메모리 분석	Volatility	메모리 덤프에서 키 추출

4. 암호화 기술 분석 (Technical Analysis)

4.1 전체 암호화 워크플로우

[실행 단계]
1. 초기화
   - 명령줄 인자 파싱 (암호화 모드 설정)
   - CSP(Cryptographic Service Provider) 획득
   - RSA 키 쌍 생성 (Cpub, Cpriv)
   ↓
2. 시스템 무력화
   - VSS(Volume Shadow Copy) 삭제 시도
   - 특정 프로세스/서비스 종료 (SQL Server, Exchange, VSS 등)
   - 방화벽 무력화
   ↓
3. 멀티스레드 암호화 엔진 초기화
   - 스레드 수 = CPU 코어 수 × 4
   - 파일 큐 관리 시스템 구축
   ↓
4. 파일 탐색 및 암호화
   - 재귀적 디렉터리 탐색
   - 파일 필터링 (.msi, .exe, .dll, .inc 제외)
   - 파일별 AES 키 생성 및 암호화 수행
   - 파일명 변경 (원본.확장자 → 원본.확장자.INC)
   ↓
5. 랜섬 노트 생성
   - INC-README.TXT 생성
   - INC-README.HTML 생성
   - 프린터로 랜섬 노트 자동 출력
   - 배경화면 변경

4.2 키 생성 및 관리 (Key Generation)

4.2.1 하이브리드 암호화 구조

RSA 키 쌍 생성

[초기 실행 시]
1. 피해자 기기별 RSA 키 쌍 생성
   - Cpub.key (Client Public Key) - 피해자 공개키
   - Cpriv.key (Client Private Key) - 피해자 개인키

2. 공격자 RSA 키 쌍 (하드코딩)
   - Spub.key (Server Public Key) - 공격자 공개키 (바이너리 내장)
   - Spriv.key (Server Private Key) - 공격자 개인키 (C&C 서버 보관)

3. Cpriv.key 보호
   - Cpriv_encrypted = RSA_Encrypt(Cpriv.key, Spub.key)
   - 암호화된 Cpriv.key를 시스템에 저장

파일별 AES 키 생성

[각 파일 암호화 시]
1. CryptGenRandom API 호출
   - 32바이트 랜덤 AES 키 생성 (AES-256)
   ★ API 후킹 지점 ★

2. AES 키로 파일 암호화
   - AES-256 CBC 모드
   - IV(Initialization Vector) 생성 (16바이트)

3. AES 키 보호
   - AES_key_encrypted = RSA_Encrypt(AES_key, Cpub.key)
   - 암호화된 AES 키를 파일 메타데이터에 저장

키 체인 구조

원본 파일
    ↓ [AES-256 암호화]
암호화된 파일
    ↓
AES 키 (32바이트)
    ↓ [RSA-2048 암호화, Cpub.key 사용]
암호화된 AES 키 (파일에 저장)
    ↓
Cpub.key (피해자 공개키)
    ↓
Cpriv.key (피해자 개인키)
    ↓ [RSA-2048 암호화, Spub.key 사용]
암호화된 Cpriv.key
    ↓
Spub.key (공격자 공개키, 하드코딩)
    ↓
Spriv.key (공격자 개인키, C&C 서버 보관)

4.2.2 공격자 공개키 (하드코딩)

# 바이너리 내 하드코딩된 공격자 RSA 공개키
ATTACKER_RSA_PUBKEY = bytes.fromhex(
    "308201..."  # 2048비트 RSA 공개키 (X.509 DER 포맷)
)

4.3 AES 암호화 알고리즘

4.3.1 AES-256 구조

암호화 모드: CBC (Cipher Block Chaining)

AES-256 CBC 파라미터:
- Key: 32바이트 (256비트)
- IV: 16바이트 (128비트)
- Block Size: 16바이트 (128비트)

CBC 모드 동작

// 첫 번째 블록
C[0] = AES_Encrypt(P[0] ⊕ IV, Key)

// 이후 블록
C[i] = AES_Encrypt(P[i] ⊕ C[i-1], Key)

여기서:
- P[i]: i번째 평문 블록
- C[i]: i번째 암호문 블록
- ⊕: XOR 연산

4.3.2 부분 암호화 (Intermittent Encryption)

INC 랜섬웨어는 암호화 속도를 극대화하기 위해 부분 암호화 기법을 사용합니다.

Fast Encryption Mode

암호화 대상: 각 파일의 처음 1,000,000 바이트만 암호화
건너뛰기: 1,000,000 바이트 이후의 데이터는 암호화하지 않음

[예시]
파일 크기 5MB:
- 암호화: 0 ~ 1,000,000 바이트
- 미암호화: 1,000,000 ~ 5,242,880 바이트

Medium Encryption Mode

암호화 대상: 1,000,000 바이트 단위로 선택적 암호화
건너뛰기: 1,000,000 바이트마다 일부 구간 건너뜀

[예시]
파일 크기 10MB:
- 암호화: 0 ~ 1,000,000 바이트
- 건너뛰기: 1,000,000 ~ 2,000,000 바이트
- 암호화: 2,000,000 ~ 3,000,000 바이트
- 건너뛰기: 3,000,000 ~ 4,000,000 바이트
- ...

명령줄 인자로 암호화 모드 선택

# Fast mode
INC_ransomware.exe -m fast

# Medium mode
INC_ransomware.exe -m medium

# Full mode (전체 암호화)
INC_ransomware.exe -m full4.3.3 AES 암호화 수행
Windows CryptoAPI 사용

4.3.3 AES 암호화 수행

Windows CryptoAPI 사용

// CSP 획득
CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT);

// 32바이트 AES 키 생성
CryptGenRandom(hProv, 32, pbKeyBlob);

// AES 키 객체 생성
CryptImportKey(hProv, pbKeyBlob, 32, 0, 0, &hKey);

// CBC 모드 설정
DWORD dwMode = CRYPT_MODE_CBC;
CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0);

// IV 설정
CryptSetKeyParam(hKey, KP_IV, pbIV, 0);

// 파일 암호화
CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwDataLen, dwBufLen);

4.4 파일 처리 아키텍처

4.4.1 멀티스레드 암호화 엔진

[멀티스레드 구조]
Main Thread
    ↓
CPU 코어 수 탐지 (GetSystemInfo)
    ↓
스레드 생성 (코어 수 × 4)
    ↓
┌─────────┬─────────┬─────────┬─────────┐
│Thread 1 │Thread 2 │Thread 3 │Thread 4 │ ...
└─────────┴─────────┴─────────┴─────────┘
     ↓          ↓          ↓          ↓
파일 큐에서 파일 가져오기 (Thread-safe Queue)
     ↓          ↓          ↓          ↓
파일 암호화 수행
     ↓          ↓          ↓          ↓
완료 카운터 증가

스레드 생성 코드 예시

// CPU 코어 수 탐지
SYSTEM_INFO si;
GetSystemInfo(&si);
DWORD dwThreadCount = si.dwNumberOfProcessors * 4;

// 스레드 생성
for (DWORD i = 0; i < dwThreadCount; i++) {
    CreateThread(NULL, 0, EncryptWorkerThread, &queueData, 0, NULL);
}

4.4.2 파일 처리 프로세스

[파일 암호화 프로세스]
1. 파일 탐색
   - FindFirstFile / FindNextFile
   - 재귀적 디렉터리 탐색
   ↓
2. 파일 필터링
   - 제외 확장자: .msi, .exe, .dll, .inc
   - 제외 디렉터리: Windows, Program Files, $RECYCLE.BIN, appdata
   ↓
3. 파일 열기
   - CreateFile (GENERIC_READ | GENERIC_WRITE)
   ↓
4. CryptGenRandom 호출
   - 32바이트 AES 키 생성
   ★ API 후킹 지점 ★
   ↓
5. AES 암호화
   - CBC 모드 초기화
   - 부분/전체 암호화 수행
   ↓
6. 메타데이터 저장
   - 암호화된 AES 키 (RSA로 암호화됨)
   - IV (16바이트)
   - 파일 크기
   - 암호화 모드 플래그
   ↓
7. 파일명 변경
   원본.확장자 → 원본.확장자.INC
   ↓
8. 파일 핸들 닫기

4.4.3 파일 메타데이터 구조

[암호화된 파일 구조]
┌─────────────────────────────────────┐
│  암호화된 파일 데이터                │
│  (AES-256 CBC)                      │
├─────────────────────────────────────┤
│  메타데이터 (Footer)                 │
│  ┌───────────────────────────────┐  │
│  │ 암호화된 AES 키 (256바이트)   │  │ ← RSA-2048로 암호화
│  ├───────────────────────────────┤  │
│  │ IV (16바이트)                 │  │
│  ├───────────────────────────────┤  │
│  │ 원본 파일 크기 (8바이트)      │  │
│  ├───────────────────────────────┤  │
│  │ 암호화 모드 플래그 (4바이트)  │  │
│  ├───────────────────────────────┤  │
│  │ 매직 바이트 "INC\x00" (4바이트)│  │
│  └───────────────────────────────┘  │
└─────────────────────────────────────┘

4.4.4 시스템 무력화

VSS 삭제

vssadmin.exe Delete Shadows /All /Quiet
wmic.exe shadowcopy delete

프로세스/서비스 종료

대상 프로세스:
- SQL Server (sqlservr.exe, sqlwriter.exe)
- Exchange (MSExchangeIS.exe, MSExchangeSA.exe)
- Backup (veeam.exe, acronis.exe)
- VSS (vss.exe)
- Antivirus (MsMpEng.exe, McShield.exe)

4.4.5 랜섬 노트 생성

랜섬 노트 경로

각 암호화된 디렉터리마다:
- INC-README.TXT
- INC-README.HTML

프린터 자동 출력

// 네트워크 프린터 탐색
EnumPrinters(PRINTER_ENUM_NETWORK, NULL, 1, ...);

// 각 프린터로 랜섬 노트 출력
for each printer:
    OpenPrinter(printerName, &hPrinter, NULL);
    StartDocPrinter(hPrinter, 1, &docInfo);
    WritePrinter(hPrinter, ransomNoteContent, ...);
    EndDocPrinter(hPrinter);
    ClosePrinter(hPrinter);

배경화면 변경

// 배경화면을 랜섬 노트 이미지로 변경
SystemParametersInfo(SPI_SETDESKWALLPAPER, 0, "C:\\INC-WALLPAPER.bmp", SPIF_UPDATEINIFILE);

4.5 정적 분석

main 함수

암호화 컨텍스트 획득

커맨드 라인 파싱

커맨드라인 별 동작
--sup : Stop Using Process (파일 잠금 프로세스 종료 활성화)
--ens : Encrypt Network Shares (네트워크 공유 폴더 암호화)
--lhd : Load Hidden Drives (숨겨진 드라이브 암호화)
--debug : 디버그 모드 활성화
--kill : 프로세스/서비스 강제 종료
--safe-mode 플래그 : 안전모드에서 실행
--hide 플래그 : 콘솔 창 숨기기
--mode f : Fast (처음 1MB만), m : Medium (선택적), s : slow (전체)
--mode s : Standard mode (1MB씩 선택적 암호화), 그 외 : Full mode
--file : 단일 파일 암호화
--dir : 디렉터리 재귀 암호화

휴지통 비우기 (복구 방지)

프로세스 종료

서비스 종료

I/O Completion Port 생성

워커 스레드

AES-CBC 암호화

AES 카운터 블록 암호화 (128비트, 14라운드)

콘솔 창 숨기기 (탐지 회피)

파일 암호화

파일 열기(읽기/쓰기 권한)

파일 사용 중인 프로세스 강제 종료 (Restart Manager API)

파일 소유권 획득

공격자 RSA 공개키 하드코딩

AES 키 생성 (32바이트)

Curve25519 키 클램핑

Curve25519 연산

SHA-512 해시

SHA-512 초기화

SHA-512 업데이트

파일 확장자 추가 (.INC)

AES 키 확장 (32바이트 -> 240바이트)

비동기 파일 읽기 (I/O Completion Port 사용) → 멀티 스레드

디렉터리 재귀 암호화

랜섬 노트 생성 (README.txt)

디렉터리 모든 파일/폴더 열거

숨겨진 드라이브 로드

5초 대기 (사용자 취소 가능성 차단)

모든 드라이브 암호화

네트워크 공유 폴더 암호화

볼륨 섀도우 복사본(VSS) 삭제

바탕화면 랜섬노트로 변경

연결된 프린터 랜섬노트 출력 (물리적)

5. 복호화 기술 분석 (Decryption Strategy)

5.1 복호화 가능성 분석

5.1.1 하이브리드 암호화 복호화 불가능 원리

복호화를 위해 필요한 키 체인:

1. 암호화된 파일 → 복호화
   필요: AES 키 (32바이트)
   
2. 암호화된 AES 키 → 복호화
   필요: Cpriv.key (피해자 개인키)
   
3. 암호화된 Cpriv.key → 복호화
   필요: Spriv.key (공격자 개인키)

문제점:
- Spriv.key는 공격자 C&C 서버에만 존재
- Cpriv.key는 Spub.key로 암호화되어 있어 Spriv.key 없이 복호화 불가능
- AES 키는 Cpub.key로 암호화되어 있어 Cpriv.key 없이 복호화 불가능

5.1.2 복호화 가능 시나리오

시나리오 1: API 후킹으로 AES 키 캡처

CryptGenRandom API 호출
         ↓
   평문 AES 키 생성 (32B)
         ↓
  ★ API 후킹 지점 ★  ← 키 캡처!
         ↓
  RSA로 AES 키 암호화
         ↓
  파일 암호화 수행

시나리오 2: 메모리 덤프에서 키 추출

암호화 진행 중 메모리 덤프
         ↓
평문 AES 키 패턴 검색
         ↓
키 후보 추출 및 검증

시나리오 3: 공격자 개인키 획득

Spriv.key 획득
         ↓
Cpriv.key 복호화
         ↓
각 파일의 AES 키 복호화
         ↓
파일 복호화

5.2 CryptGenRandom 키 복구 메커니즘

취약점 구조

[암호화 프로세스]
CreateFile("target.docx")
         ↓
CryptGenRandom(hProv, 32, pbKeyBlob)  ← 평문 AES 키 생성
         ↓
  ★ API 후킹 지점 ★
  - 32바이트 평문 AES 키 캡처
  - 파일명과 매핑하여 저장
         ↓
CryptImportKey(..., pbKeyBlob, 32, ...)  ← 키 객체 생성
         ↓
CryptEncrypt(...)  ← 파일 암호화
         ↓
RSA_Encrypt(pbKeyBlob, Cpub.key)  ← AES 키 암호화
         ↓
WriteFile(hFile, encryptedKey, ...)  ← 암호화된 키 저장
         ↓
ZeroMemory(pbKeyBlob, 32)  ← 평문 키 메모리 소거

5.3 자동화 복호화 스크립트 개발

5.3.1 핵심 복호화 로직

1. 암호화된 파일 메타데이터 추출

import struct

def extract_metadata(encrypted_file_path):
    """파일 Footer에서 메타데이터 추출"""
    with open(encrypted_file_path, 'rb') as f:
        # 파일 끝으로 이동
        f.seek(-288, 2)  # 256 + 16 + 8 + 4 + 4 = 288 바이트
        
        # 메타데이터 읽기
        encrypted_aes_key = f.read(256)  # RSA-2048로 암호화된 AES 키
        iv = f.read(16)                  # IV
        original_size = struct.unpack('<Q', f.read(8))[0]  # 원본 크기
        mode_flag = struct.unpack('<I', f.read(4))[0]      # 암호화 모드
        magic = f.read(4)                # 매직 바이트
        
        if magic != b'INC\x00':
            raise ValueError("Invalid INC ransomware file")
        
        return {
            "encrypted_aes_key": encrypted_aes_key,
            "iv": iv,
            "original_size": original_size,
            "mode_flag": mode_flag
        }

2. AES-256 CBC 복호화

from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad

def decrypt_file_aes(encrypted_file_path, aes_key_hex, output_path):
    """AES-256 CBC 모드로 파일 복호화"""
    # 메타데이터 추출
    metadata = extract_metadata(encrypted_file_path)
    iv = metadata["iv"]
    original_size = metadata["original_size"]
    mode_flag = metadata["mode_flag"]
    
    # AES 키 변환
    aes_key = bytes.fromhex(aes_key_hex)
    
    # 암호화된 데이터 읽기
    with open(encrypted_file_path, 'rb') as f:
        encrypted_data = f.read()
    
    # 메타데이터 제거 (Footer 288바이트)
    encrypted_data = encrypted_data[:-288]
    
    # AES 복호화
    cipher = AES.new(aes_key, AES.MODE_CBC, iv)
    
    if mode_flag == 1:  # Fast mode - 처음 1MB만 암호화됨
        decrypted_chunk = cipher.decrypt(encrypted_data[:1_000_000])
        decrypted_data = decrypted_chunk + encrypted_data[1_000_000:]
    elif mode_flag == 2:  # Medium mode - 1MB씩 선택적 암호화
        decrypted_data = bytearray()
        offset = 0
        while offset < len(encrypted_data):
            if (offset // 1_000_000) % 2 == 0:  # 짝수 청크는 암호화됨
                chunk_size = min(1_000_000, len(encrypted_data) - offset)
                decrypted_chunk = cipher.decrypt(encrypted_data[offset:offset+chunk_size])
                decrypted_data.extend(decrypted_chunk)
                # 다음 청크를 위해 cipher 재초기화
                cipher = AES.new(aes_key, AES.MODE_CBC, encrypted_data[offset+chunk_size-16:offset+chunk_size])
            else:  # 홀수 청크는 평문
                decrypted_data.extend(encrypted_data[offset:offset+1_000_000])
            offset += 1_000_000
    else:  # Full mode - 전체 암호화
        decrypted_data = cipher.decrypt(encrypted_data)
        # PKCS7 패딩 제거
        try:
            decrypted_data = unpad(decrypted_data, AES.block_size)
        except:
            pass  # 패딩이 없는 경우
    
    # 원본 크기로 자르기
    decrypted_data = decrypted_data[:original_size]
    
    return True

3. 매직 바이트 검증

def verify_decryption(output_path, expected_ext):
    """복호화 결과의 매직 바이트 검증"""
    magic_bytes = {
        '.jpg': b'\xFF\xD8\xFF',
        '.png': b'\x89PNG\r\n\x1a\n',
        '.pdf': b'%PDF',
        '.docx': b'PK\x03\x04',
        '.xlsx': b'PK\x03\x04',
        '.zip': b'PK\x03\x04',
        '.exe': b'MZ',
        '.dll': b'MZ'
    }
    
    ext = expected_ext.lower()
    if ext not in magic_bytes:
        return None  # 검증할 수 없는 파일 형식
    
    with open(output_path, 'rb') as f:
        header = f.read(len(magic_bytes[ext]))
    
    return header == magic_bytes[ext]

5.4 무결성 검증

5.4.1 매직 바이트 테이블

파일 유형	매직 넘버 (Hex)	설명
JPG/JPEG	FF D8 FF E0/E1/DB	JPEG 이미지
PNG	89 50 4E 47 0D 0A 1A 0A	PNG 이미지
PDF	25 50 44 46	PDF 문서
DOCX	50 4B 03 04	Office Open XML (ZIP)
XLSX	50 4B 03 04	Office Open XML (ZIP)
ZIP	50 4B 03 04	ZIP 압축 파일
EXE/DLL	4D 5A	Windows 실행 파일 (MZ)
MP3	FF FB / ID3	MP3 오디오
MP4	00 00 00 18/20 66 74 79 70	MPEG-4 비디오

6. 요약 및 결론 (Conclusion)

6.1 최종 평가

INC 랜섬웨어는 AES-256 대칭 암호화와 RSA-2048 비대칭 암호화를 결합한 하이브리드 방식을 채택하여, 공격자 개인키 없이는 복호화가 불가능한 구조를 가지고 있습니다. **부분 암호화(Intermittent Encryption)**와 멀티스레딩(CPU 코어 × 4) 기법을 통해 암호화 속도를 극대화하며, VSS 삭제 및 프로세스 종료를 통해 복구를 방해합니다.

그러나 CryptGenRandom API 호출 시점에 평문 AES 키가 메모리에 존재하는 구조적 취약점으로 인해, API 후킹을 통한 실시간 키 캡처가 가능하며, 이를 활용한 완벽한 복호화가 실증되었습니다.

[취약점 요약]
CryptGenRandom(32바이트)
         ↓
   평문 AES 키 생성
         ↓
  ★ API 후킹 지점 ★
         ↓
RSA-2048 키 암호화
         ↓
AES-256 CBC 파일 암호화
         ↓
  파일 암호화 완료

6.2 대응 가이드

6.2.1 예방적 조치

1. API 모니터링 강화

CryptGenRandom 호출 패턴 실시간 탐지
의심스러운 대량 난수 생성 차단 (32바이트 × 수백 회)
멀티스레드 암호화 패턴 탐지 (CPU 코어 × 4 스레드)

2. 행위 기반 탐지

대량 파일 접근 패턴 탐지 (수천 개 파일 동시 접근)
.INC 확장자 추가 행위 차단
VSS 삭제 시도 탐지 및 차단
프린터 자동 출력 시도 차단

3. 네트워크 방어

CVE-2023-3519 (Citrix NetScaler) 패치 적용
RDP 접근 제한 및 MFA 적용
의심스러운 PowerShell/WMI 실행 차단

4. 파일 시스템 보호

실시간 백업 시스템 구축 (오프라인 백업 포함)
VSS 보호 솔루션 적용
중요 파일 읽기 전용 설정

6.2.2 사후 대응

1. 초동 조치

감염 발견 즉시 시스템 격리 (네트워크 차단)
메모리 덤프 수행 (시스템 종료 금지!)
프로세스 메모리에서 평문 AES 키 추출 시도

2. 키 복구 전략

API 후킹 도구로 CryptGenRandom 로그 확보
- Detours 라이브러리 활용
- 후킹 DLL 인젝션
- JSON 로그 파일 수집
메모리 포렌식으로 AES 키 패턴 추출
- Volatility Framework 활용
- 32바이트 패턴 검색 (높은 엔트로피)
- 파일명과 키 매핑
API 후킹 로그에서 키 후보 도출
- 타임스탬프 기반 파일-키 매핑
- 키 검증 (매직 바이트 확인)

3. 복호화 수행

추출한 AES 키로 파일 복호화
매직 바이트 검증 및 무결성 확인

4. 시스템 복구

복호화 성공 후 시스템 재구축
초기 침투 경로 분석 및 패치
보안 솔루션 강화

6.3 기술적 특징 요약

항목	세부 내용
암호화 알고리즘	AES-256 CBC (대칭) + RSA-2048 (비대칭)
키 관리	파일별 독립 32바이트 AES 키 (CryptGenRandom)
하이브리드 구조	AES로 파일 암호화 → RSA로 AES 키 암호화
부분 암호화	Fast/Medium 모드 (1,000,000 바이트 단위)
멀티스레딩	CPU 코어 수 × 4 스레드
확장자	.INC
랜섬 노트	INC-README.TXT, INC-README.HTML
초기 침투	CVE-2023-3519 (Citrix NetScaler), Phishing
복호화 가능성	API 후킹으로 AES 키 확보 시 100% 복구 가능
회피 기법	VSS 삭제, 프로세스 종료, 배경화면 변경, 프린터 출력

6.4 결론

INC 랜섬웨어는 AES-256과 RSA-2048을 결합한 강력한 하이브리드 암호화 구조를 가지고 있으며, 부분 암호화와 멀티스레딩을 통해 암호화 속도를 극대화하는 정교한 랜섬웨어입니다. 2023년 7월 등장 이후 300명 이상의 피해자를 발생시키며 지속적으로 활동하고 있습니다.

그러나 CryptGenRandom API를 직접 호출하는 설계상 취약점으로 인해, API 후킹을 통한 실시간 AES 키 캡처가 가능하며, 이를 활용한 복호화가 실증되었습니다. 본 분석에서 개발한 자동화 복호화 도구는 INC 랜섬웨어 감염 피해 복구에 직접 활용될 수 있습니다.

향후 대응을 위해서는 암호화 API 실시간 모니터링 체계 구축, 메모리 포렌식 역량 강화, CVE-2023-3519 패치 적용, 다층 백업 전략 수립이 필수적입니다. 특히 감염 초기에 메모리 덤프를 확보하고, API 후킹 도구를 사전에 배포하는 것이 복호화 성공률을 극대화할 수 있습니다.

Cloak 랜섬웨어 분석 보고서

geonwoo9643 — Fri, 6 Feb 2026 16:29:05 +0900

1. 개요 (Overview)

1.1 분석 배경

Cloak 랜섬웨어는 Mammona 랜섬웨어의 변종으로 추정되는 악성코드로, ECDH(Curve25519) 키 교환과 HC-128 스트림 암호화를 결합한 하이브리드 암호화 방식을 사용합니다. 프로세스 교체(Process Hollowing) 및 자가 삭제 메커니즘을 통해 분석을 회피하며, 안티디버깅 로직을 내장하고 있습니다. 본 보고서는 Cloak의 암호학적 구조를 정밀 분석하고, API 후킹을 통한 실시간 키 추출 및 복호화 전략을 제시합니다.

1.2 핵심 요약

암호화 메커니즘

ECDH(Curve25519) 키 교환 프로토콜을 통한 파일별 공유 비밀 생성
HC-128 스트림 암호를 사용한 고속 파일 암호화
SHA-512 기반 KDF(Key Derivation Function)로 HC-128 Key/IV 도출

회피 기법

프로세스 교체 및 자가 삭제 메커니즘
안티디버깅 로직 내장
휴지통 비우기, VSS 삭제, 방화벽 무력화

복호화 가능성

CryptGenRandom API 호출 시점의 파일별 개인키를 API 후킹으로 실시간 캡처 시 완벽한 복호화 가능
공격자 개인키 없이는 복호화 불가능
본 분석에서 개발한 자동화 복호화 스크립트로 실증 검증 완료

2. 식별 정보 (Identification)

Malware Family: Cloak (Mammona 변종)

Filetype: PE32 (Windows Executable)

Hash (SHA256): d6af700fb86d3a3a832ba49273453b9c35c89978e4855ce9033b9770d938881c

Extension: .crYpt

Target: Windows 기반 시스템

3. 분석 환경 및 도구 (Tools)

구분	도구명 (Tool)	용도 (Purpose)
정적 분석	IDA Pro	ECDH/HC-128 구현 루틴 및 암호화 로직 분석
동적 분석	CryptGenRandom API Hooking	실시간 개인키 추출
행위 분석	Process Monitor	파일 I/O 및 암호화 행위 추적
암호 분석	Python	ECDH 연산 및 HC-128 복호화 스크립트 개발

4. 암호화 기술 분석 (Technical Analysis)

4.1 전체 암호화 워크플로우

[실행 단계]
1. WinMain 초기화
   - 안티디버깅 로직 실행
   - 프로세스 교체 (Process Hollowing)
   - 자가 삭제 메커니즘 활성화
   ↓
2. 시스템 무력화
   - 휴지통 비우기
   - VSS(Volume Shadow Copy) 삭제
   - 방화벽 비활성화
   - CryptAcquireContext로 암호화 공급자 획득
   ↓
3. 암호화 스레드 생성
   - reateThread 호출
   - StartAddress로 암호화 워커 스레드 실행
   ↓
4. 파일별 암호화 수행
   - 파일 탐색 및 필터링
   - 암호화 함수 호출
   - 파일명 변경 (원본.확장자 → 원본.확장자.crYpt)

4.2 키 생성 및 관리 (Key Generation)

4.2.1 ECDH 키 교환 프로토콜

Curve25519 기반 키 교환

정의:
- G = BasePoint (Curve25519 → 9)
- a = 파일별 피해자 개인키 (CryptGenRandom으로 생성, 32바이트)
- A = 파일별 피해자 공개키
- b = 공격자 개인키 (미공개)
- B = 공격자 공개키 (하드코딩)
- s = 공유 비밀 (암호화 키 도출용)

키 교환 과정:
1. A = Curve25519(a, G)  // 피해자 공개키 생성
2. s = Curve25519(a, B)  // 공유 비밀 생성
3. A를 파일 메타데이터에 저장 (복호화 시 사용)

공격자 공개키 (하드코딩)

ATTACKER_PUBKEY_CRYPT = bytes.fromhex(
    "3B4C31C6857B5C176EE766CDC3CE7DF291E76373926E9801B1D73F61F5D77B07"
)

4.2.2 SHA-512 KDF (Key Derivation Function)

/ ECDH 공유 비밀 생성
shared_secret = Curve25519(victim_privkey, attacker_pubkey);

// SHA-512 해싱
master_key = SHA512(shared_secret);  // 64바이트

// 키 분할
hc128_key = master_key[0:32];   // HC-128 Key (32바이트)
hc128_iv  = master_key[32:64];  // HC-128 IV (32바이트)

4.3 HC-128 스트림 암호화 알고리즘

4.3.1 HC-128 초기화

State 구조

HC-128 State (2560비트):
- P[512]: 32비트 워드 배열 (2048비트)
- Q[512]: 32비트 워드 배열 (2048비트)
- Key: 32바이트 (256비트)
- IV: 32바이트 (256비트)

초기화 과정

// 1. Key/IV로 State 초기화
init_state(state, key_words, 256, 256);

// 2. IV 적용
apply_iv(state, iv_words);

// 3. 키스트림 생성 준비
prepare_keystream(state);

4.3.2 키스트림 생성 및 XOR 암호화

// 키스트림 생성 및 XOR 연산
ReadFile(hFile, lpBuffer, FileSize.LowPart, &NumberOfBytesRead, 0);
hc128_xor_encrypt(state, lpBuffer, lpBuffer, NumberOfBytesRead);
WriteFile(hFile, lpBuffer, NumberOfBytesRead, &NumberOfBytesWritten, 0);

암호화 수식

Ciphertext[i] = Plaintext[i] ⊕ HC128_Keystream[i]

4.4 파일 처리 아키텍처

[파일 암호화 프로세스]
1. 파일 열기 (CreateFile)
   ↓
2. CryptGenRandom 호출
   - 32바이트 개인키 생성 (a)
   ★ API 후킹 지점 ★
   ↓
3. ECDH 키 교환
   - A = Curve25519(a, G)
   - s = Curve25519(a, B)
   ↓
4. KDF 수행
   - master = SHA512(s)
   - key = master[0:32]
   - iv = master[32:64]
   ↓
5. HC-128 초기화
   - State 초기화 (key, iv)
   ↓
6. 파일 암호화
   - HC-128 키스트림 생성
   - XOR 연산
   - 암호화 데이터 쓰기
   ↓
7. 파일명 변경
   원본.확장자 → 원본.확장자.crYpt

4.5 정적 분석

WinMain

CSP(Cryptographic Service Provider) 컨텍스트 획득

Mutex 생성 (중복 실행 방지)

각 드라이브 별 파일 암호화 수행 (시스템 내 논리 드라이브)

드라이브 암호화 시작

디렉터리 재귀 탐색

파일/폴더 필터링 및 제외

파일 큐 관리 함수

암호화 스레드 생성 (CPU 코어 수)

암호화 워커 스레드

암호화 함수

파일 속성 변경

파일 확장자 변경

파일 열기 (읽기/쓰기 권한)

공개키 로드

개인 키 생성 (32바이트)

Curve25519 스칼라 곱셈 (공개 키 생성)

Curve25519 ECDH (공유 비밀 생성)

SHA-512 KDF (64바이트 마스터 키 생성)

HC-128 State 초기화

파일 크기 별 분기

파일 암호화

파일 끝 메타데이터 추가

Curve25519 스칼라 곱셈 함수

SHA-512 해싱 함수

HC-128 State 초기화 함수

HC-128 키스트림 XOR 함수

5. 복호화 기술 분석 (Decryption Strategy)

5.1 복호화 가능성 분석

ECDH 복호화 불가능 원리

공유 비밀 복원 조건:
s = Curve25519(a, B) = Curve25519(b, A)

복호화를 위해 필요:
- 피해자 개인키(a) 또는 공격자 개인키(b)

문제점:
- 피해자는 a를 모름 (CryptGenRandom 후 메모리에서 소멸)
- 공격자만 b를 보유
- A만으로는 a를 역산 불가능 (이산로그 문제)

5.2 CryptGenRandom 키 복구 메커니즘

취약점 구조

CryptGenRandom API 호출
         ↓
   평문 개인키 생성 (32B)
         ↓
  ★ API 후킹 지점 ★  ← 키 캡처!
         ↓
  ECDH 공유 비밀 계산
         ↓
   SHA-512 KDF
         ↓
  HC-128 암호화 수행

5.3 자동화 복호화 스크립트 개발

5.3.1 핵심 복호화 로직

1. 개인키 후보 도출

def derive_candidates_from_json(json_path, attacker_pubkey):
    """JSON에서 CryptGenRandom(32바이트) 이벤트 추출"""
    candidates = []
    
    for ev in events:
        if (ev.get("api") == "CryptGenRandom" and 
            ev.get("length_bytes") == 32):
            
            priv = bytes.fromhex(ev["payload_hex"])
            
            # ECDH 공유 비밀 계산
            shared = x25519(priv, attacker_pubkey)
            
            # SHA-512 KDF
            master = hashlib.sha512(shared).digest()
            key = master[:32]
            iv = master[32:64]
            
            candidates.append({
                "source_priv": ev["payload_hex"],
                "key_hex": key.hex(),
                "iv_hex": iv.hex()
            })
    
    return candidates

2. HC-128 복호화

def decrypt_bytes_hc128(cipher: bytes, key_hex: str, iv_hex: str) -> bytes:
    """HC-128 스트림 암호 복호화 (XOR 기반)"""
    key = bytes.fromhex(key_hex)
    iv = bytes.fromhex(iv_hex)
    
    # State 초기화
    state = alloc_state()
    init_state(state, key_words, 256, 256)
    apply_iv(state, iv_words)
    
    # 키스트림 생성 및 XOR
    out = bytearray(cipher)
    generate_keystream_xor(state, cipher[:dec_len], out, dec_len)
    
    return bytes(out)

3. 매직 바이트 검증

def looks_valid_magic(output_path, data: bytes) -> bool:
    """복호화 결과 시그니처 검증"""
    ext = os.path.splitext(output_path)[1].lower()
    
    if ext in (".jpg", ".jpeg"):
        return data.startswith(b"\xFF\xD8\xFF")  # JPEG SOI
    if ext == ".png":
        return data.startswith(b"\x89PNG\r\n\x1a\n")
    if ext == ".pdf":
        return data.startswith(b"%PDF")
    # ...

5.4 무결성 검증

파일 유형	매직 넘버 (Hex)	설명
JPG	FF D8 FF E0/E1/DB	JPEG 이미지
PNG	89 50 4E 47 0D 0A 1A 0A	PNG 이미지
PDF	25 50 44 46	PDF 문서
ZIP/DOCX	50 4B 03 04	압축 파일
EXE/DLL	4D 5A	Windows 실행 파일

6. 요약 및 결론 (Conclusion)

6.1 최종 평가

Cloak 랜섬웨어는 암호학적으로 안전한 ECDH + HC-128 하이브리드 방식을 채택하여, 공격자 개인키 없이는 복호화가 불가능한 구조를 가지고 있습니다. 그러나 CryptGenRandom API 호출 시점에 평문 개인키가 메모리에 존재하는 구조적 취약점으로 인해, API 후킹을 통한 실시간 키 캡처가 가능하며, 이를 활용한 완벽한 복호화가 실증되었습니다.

[취약점 요약]
CryptGenRandom(32바이트)
         ↓
   평문 개인키 생성
         ↓
  ★ API 후킹 지점 ★
         ↓
ECDH + SHA-512 + HC-128
         ↓
  파일 암호화 완료

6.2 대응 가이드

6.2.1 예방적 조치

API 모니터링 강화
- CryptGenRandom 호출 패턴 실시간 탐지
- 의심스러운 대량 난수 생성 차단
행위 기반 탐지
- 대량 파일 접근 패턴 탐지
- .crYpt 확장자 추가 행위 차단
- 프로세스 교체(Process Hollowing) 탐지
파일 시스템 보호
- 실시간 백업 시스템 구축
- VSS 삭제 시도 탐지 및 차단

6.2.2 사후 대응

초동 조치
- 감염 발견 즉시 시스템 격리
- 메모리 덤프 수행 (시스템 종료 금지)
- 프로세스 메모리에서 CryptGenRandom 키 추출
키 복구
- API 후킹 도구로 CryptGenRandom 로그 확보
- 메모리 포렌식으로 32바이트 개인키 패턴 추출
- JSON 로그 파일에서 키 후보 도출
복호화 수행
- 추출한 개인키로 ECDH 공유 비밀 재계산
- HC-128 복호화 및 매직 바이트 검증

6.3 기술적 특징 요약

항목	세부 내용
암호화 알고리즘	ECDH(Curve25519) + HC-128 Stream Cipher
키 관리	파일별 독립 32바이트 개인키 (CryptGenRandom)
KDF	SHA-512 (64바이트 출력 → 32B Key + 32B IV)
확장자	.crYpt
공격자 공개키	하드코딩 (3B4C31C6857B5C...)
복호화 가능성	API 후킹으로 개인키 확보 시 100% 복구 가능
회피 기법	프로세스 교체, 자가 삭제, 안티디버깅

6.4 결론

Cloak 랜섬웨어는 ECDH 키 교환과 HC-128 스트림 암호화를 결합한 강력한 암호학적 구조를 가지고 있지만, 키 생성 과정에서 CryptGenRandom API를 직접 호출하는 설계상 취약점으로 인해 API 후킹을 통한 복호화가 가능합니다. 본 분석에서 개발한 자동화 복호화 도구는 Cloak 감염 피해 복구에 직접 활용될 수 있으며, 향후 유사 랜섬웨어 대응을 위해서는 암호화 API 실시간 모니터링 체계 구축과 메모리 포렌식 역량 강화가 필수적입니다.

Akira 랜섬웨어 분석 보고서

geonwoo9643 — Fri, 6 Feb 2026 04:28:53 +0900

1. 개요 (Overview)

Akira 랜섬웨어는 2024년 11월에 관측된 ChaCha 스트림 암호 기반 랜섬웨어다. Windows CryptoAPI의 CryptGenRandom으로 생성한 암호화 키를 가공 없이 ChaCha State에 직접 사용하며, 표준 ChaCha20 대비 라운드 수를 절반으로 축소한 ChaCha8 변형을 사용한다. 파일 크기의 절반만 암호화하는 부분 암호화 방식으로 속도를 최적화했으며, 534바이트 Footer에 RSA로 암호화된 키 정보를 저장한다.

2. 식별 정보 (Identification)

Malware Family: Akira
Filetype: PE32 (Windows Executable)
Hash (SHA256): 2e2ad6392e75d5a5155498c2a76cb373d17ca3ad4ba57c6d33c623fca5e29342
Extension: .akira
First Seen: 2024-11-05 12:20:13 UTC
Target: Windows 기반 시스템 (x64)

3. 분석 환경 및 도구 (Tools)

구분	도구명 (Tool)	용도 (Purpose)
정적 분석	IDA Pro	ChaCha8 구현 루틴 및 암호화 로직 분석
동적 분석	CryptGenRandom API Hooking (Detours)	실시간 키 및 nonce 추출
행위 분석	Process Monitor	파일 I/O 및 암호화 행위 추적
검증 도구	Python	ChaCha8 복호화 스크립트 개발 및 PoC

4. 암호화 기술 분석 (Technical Analysis)

4.1 암호화 키 생성

CryptGenRandom(32 bytes) → Key Storage (a1+312)
CryptGenRandom(8 bytes) → Nonce Storage (a1+304)
         ↓
RSA 암호화용 복사본 생성 (Footer 저장)
         ↓
원본 키/논스 유지 (가공 없음)

핵심 특징: CryptGenRandom 출력값을 가공 없이 ChaCha State에 직접 사용

4.2 ChaCha State 초기화

state[0-3]   = "expand 32-byte k"  # 상수
state[4-11]  = Key (32 bytes, 8 words from a1+312)
state[12-13] = Counter = 0
state[14-15] = Nonce (8 bytes, 2 words from a1+304)

4.3 커스텀 ChaCha8 구현

라운드 구조

구분	표준 ChaCha20	Akira ChaCha8
Double Rounds	10	4
Quarter Rounds	20	8
블록 크기	64 bytes	64 bytes

4번 반복 (Double Round)

Round 1: Column Round + Diagonal Round
Round 2: Column Round + Diagonal Round
Round 3: Column Round + Diagonal Round
Round 4: Column Round + Diagonal Round

Keystream 생성

변환된 State + 원본 State = Keystream (64 bytes)
Ciphertext ⊕ Keystream = Plaintext

4.4 파일 암호화 구조 (> 2,000,000 bytes)

graph TD
    A[Original File] --> B[Encrypted Block<br/>Size: File Size / 2]
    A --> C[Plain Text Block<br/>Size: File Size / 2]
    B --> D[Encrypted File]
    C --> D
    E[File Footer<br/>534 bytes<br/>RSA Encrypted Key/Nonce] --> D

**구조 상세**

| Block Type | Size |
|------------|------|
| Encrypted Block | File Size / 2 |
| Plain Text Block | File Size / 2 |
| File Footer | 534 bytes |

4.5 암호화 함수 흐름

암호화 함수
    ↓
키/논스 생성 및 저장
    ↓
ChaCha State 초기화
    ↓
4 Double Rounds 실행
    ↓
Keystream 생성
    ↓
XOR 암호화 (파일 절반만)
    ↓
Footer 추가 (RSA 암호화된 키/논스)

4.6 정적 분석

main 함수

명령줄 인자

--encryption_path: 암호화 대상 경로
--share_file: 공유 파일 목록
--encryption_percent: 파일 암호화 비율 (기본 50%)
-l: 로컬 드라이브만 대상

파일 목록 수집

RSA 공개키 로드 (Microsoft Enhanced RSA and AES Provider)

스레드 풀 생성 (CPU 코어 수)

파일 목록 순회

암호화 함수 호출 (경로, RSA키, 암호화 비율, 네트워크 공유 플래그)

암호화 작업 완료 대기

소요 시간 출력

메인 암호화 State Machine

State 2: 암호화 초기화

CryptGenRandom 키/논스 생성

ChaCha State 초기화

파일 열기

파일 크기 확인

암호화 모드 결정 (≤ 2MB → 전체 암호화 / > 2MB → 절반만 암호화)

전체 암호화 (≤ 2MB)

스팟 암호화

절반 암호화 (> 2MB)

ChaCha8 암호화

Footer 작성 (1바이트 플래그 + 4바이트 크기 + RSA 암호화된 키/Nonce)

파일명 변경 (.akira 확장자 추가)

5. 복호화 기술 분석 (Decryption Strategy)

5.1 후킹 기반 키 추출

모니터링 대상 API

CryptGenRandom : 키/논스 생성 시점 캡처
CreateFileW : 암호화 대상 파일 식별
WriteFile : Footer 작성 모니터링

5.2 복호화 스크립트 분석

복호화 로직

# 1. State 초기화
state = [
    0x61707865, 0x3320646e, 0x79622d32, 0x6b206574,  # "expand 32-byte k"
    ...key (8 words)...,
    0, 0,  # counter (64-bit)
    ...nonce (2 words)...
]

# 2. 64바이트 블록 단위 복호화
while pos < encrypted_size:
    state[12] = counter_low
    state[13] = counter_high
    keystream = custom_chacha_block_exact(state)
    plaintext = ciphertext ⊕ keystream
    counter += 1

스크립트 기능

JSON 파일에서 후킹된 키/논스 자동 추출
다중 키 쌍 지원 (여러 키로 순차 시도)
파일 타입 자동 검증 (JPEG, PNG, 텍스트)

5.3 복호화 검증

자동 파일 타입 검증

JPEG : Magic bytes FF D8
PNG : Magic bytes 89 50 4E 47
텍스트 : Printable ratio > 80%

6. 요약 및 결론 (Conclusion)

6.1 기술적 특징

암호화 메커니즘

구성 요소	구현
키 생성	CryptGenRandom (32 bytes, 가공 없음)
논스 생성	CryptGenRandom (8 bytes, 가공 없음)
스트림 암호	ChaCha8 (4 double rounds)
키 보호	RSA 공개키 암호화
암호화 범위	파일 크기 50% (≤ 2MB)
Footer	534 bytes

성능 최적화

라운드 수 감소 : ChaCha20 → ChaCha8 (속도 2배 향상)
부분 암호화 : 파일 절반만 암호화 (I/O 50% 감소)
가공 없는 키 사용 : 추가 연산 제거

6.2 보안 약점

약점 1: 축소된 라운드

ChaCha8 (8 quarter rounds)은 표준 ChaCha20 (20 quarter rounds) 대비 보안 강도 감소
Cryptanalysis 공격 가능성 증가

약점 2: 부분 암호화

파일 절반이 평문 노출
문서/이미지 파일의 경우 내용 일부 복원 가능

약점 3: 키 보호 의존성

암호화 키 자체는 강력하나, RSA 공개키만 의존
메모리 덤프/API 후킹 시 키 추출 가능

6.3 복호화 가능 조건

필수 정보

32바이트 ChaCha 키 (가공 전 원본)
8바이트 논스 (가공 전 원본)

추출 방법

API 후킹: CryptGenRandom 호출 시점 캡처
메모리 덤프: 암호화 프로세스 메모리 분석 (a1+312, a1+304 오프셋)
Footer 분석: RSA 개인키 확보 시 복호화 가능

Devman 랜섬웨어 분석 보고서

geonwoo9643 — Thu, 5 Feb 2026 18:27:51 +0900

1. 개요 (Overview)

1.1 분석 배경

DevMan 랜섬웨어는 2025년 초부터 활발히 유포되고 있는 악성코드로, ChaCha8 스트림 암호화를 기반으로 한 경량화된 암호화 방식을 채택하고 있습니다. DragonForce 랜섬웨어의 변종으로 추정되며, 유사한 암호화 메커니즘을 사용하지만 더 단순화된 구조를 가지고 있습니다. 본 보고서는 DevMan의 암호학적 구조를 정밀 분석하고, API 후킹을 통한 실시간 키 추출 기법과 복호화 전략을 제시합니다.

1.2 핵심 요약

경량화된 암호화 구조 : ChaCha8 스트림 암호화를 사용하여 빠른 암호화 속도를 달성합니다. 4번의 더블 라운드를 수행하여 성능과 보안성의 균형을 추구합니다.
파일별 독립 키 생성 : 각 파일마다 고유한 32바이트 키와 8바이트 nonce를 CryptGenRandom API를 통해 생성합니다.
단순화된 암호화 전략 : 복잡한 파일 크기별 전략 없이 일관된 암호화 방식을 적용합니다.
완벽한 복호화 가능성 : CryptGenRandom API 호출 시점에 생성되는 평문 키를 API 후킹으로 실시간 캡처할 경우, 완벽한 복호화가 가능합니다. 본 분석에서 개발한 복호화 스크립트를 통해 실증적으로 검증되었습니다.

2. 식별 정보 (Identification)

Malware Family: DevMan
Filetype: PE32 (Windows Executable)
Hash (SHA256): df5ab9015833023a03f92a797e20196672c1d6525501a9f9a94a45b0904c7403
Extension: .devman
Target: Windows 기반 시스템

3. 분석 환경 및 도구 (Tools)

구분	도구명 (Tool)	용도 (Purpose)
정적 분석	IDA Pro	ChaCha8 구현 루틴 및 암호화 로직 분석
동적 분석	CryptGenRandom API Hooking (x86)	실시간 키 및 nonce 추출
행위 분석	Process Monitor	파일 I/O 및 암호화 행위 추적
검증 도구	Python	ChaCha8 복호화 스크립트 개발 및 PoC

4. 암호화 기술 분석 (Technical Analysis)

4.1 전체 암호화 워크플로우

DevMan은 단순화된 암호화 모델을 기반으로 다음과 같은 4단계 프로세스를 거칩니다.

키 및 Nonce 생성 : CryptGenRandom API를 통해 파일별로 고유한 32바이트 ChaCha 키와 8바이트 nonce를 생성
ChaCha State 초기화 : 생성된 키와 nonce로 ChaCha state를 초기화하고 카운터를 0으로 설정
파일 암호화 : ChaCha8 알고리즘을 사용하여 파일 전체를 암호화
파일명 변경 : 암호화된 파일의 확장자를 .devman으로 변경

4.2 키 생성 및 관리 (Key Generation)

4.2.1 CryptGenRandom을 통한 난수 생성

DevMan은 Windows CryptoAPI의 CryptGenRandom 함수를 사용하여 암호학적으로 안전한 난수를 생성합니다.

// 각 파일마다 고유한 키와 nonce 생성
CryptGenRandom(hProv, 32, chacha_key);    // 32바이트 ChaCha Key
CryptGenRandom(hProv, 8, chacha_nonce);   // 8바이트 ChaCha Nonce

4.2.2 ChaCha State 초기화

생성된 키와 nonce를 사용하여 ChaCha state를 초기화합니다.

Constant : "expand 32-byte k" (ChaCha 표준 상수)
Key : CryptGenRandom으로 생성한 32바이트 난수
Counter : 0으로 초기화 (블록마다 1씩 증가)
Nonce : CryptGenRandom으로 생성한 8바이트 난수

ChaCha State 구조 (64바이트):

Constant (16B)

Key (32B)

Counter (8B)

Nonce (8B)

4.3 ChaCha8 암호화 알고리즘

4.3.1 ChaCha8 키스트림 생성

ChaCha8은 일반적인 ChaCha20의 10번 더블 라운드 대신, 4번의 더블 라운드를 수행하여 성능을 최적화한 변형입니다.

ChaCha8 라운드 구조:
┌─────────────────────────────────┐
│    Initial State (64 bytes)     │
│  [Constant | Key | Ctr | Nonce] │
└─────────────────────────────────┘
            ↓
    ┌───────────────┐
    │ Double Round  │  ← 4번 반복 (ChaCha8)
    │ (QR 함수 8회) │
    └───────────────┘
            ↓
┌─────────────────────────────────┐
│      Keystream (64 bytes)       │
└─────────────────────────────────┘

4.3.2 Quarter Round 연산

Quarter Round (a, b, c, d):
    a += b; d ^= a; d <<<= 16;
    c += d; b ^= c; b <<<= 12;
    a += b; d ^= a; d <<<= 8;
    c += d; b ^= c; b <<<= 7;

4.3.3 ChaCha8 블록 생성

def chacha_block(key32, counter, nonce64, rounds=8):
    constants = b"expand 32-byte k"
    key_words = list(struct.unpack("<8I", key32))
    nonce_words = list(struct.unpack("<2I", nonce64))
    counter_low = counter & 0xffffffff
    counter_high = (counter >> 32) & 0xffffffff
    
    # Initial state 구성
    state = [
        struct.unpack("<I", constants[0:4])[0],
        struct.unpack("<I", constants[4:8])[0],
        struct.unpack("<I", constants[8:12])[0],
        struct.unpack("<I", constants[12:16])[0],
    ] + key_words + [counter_low, counter_high] + nonce_words
    
    working = state.copy()
    
    # 4번의 더블 라운드
    for _ in range(rounds // 2):
        # Column round
        quarter_round(working, 0, 4, 8, 12)
        quarter_round(working, 1, 5, 9, 13)
        quarter_round(working, 2, 6, 10, 14)
        quarter_round(working, 3, 7, 11, 15)
        
        # Diagonal round
        quarter_round(working, 0, 5, 10, 15)
        quarter_round(working, 1, 6, 11, 12)
        quarter_round(working, 2, 7, 8, 13)
        quarter_round(working, 3, 4, 9, 14)
    
    # Add initial state
    out = [(working[i] + state[i]) & 0xffffffff for i in range(16)]
    return struct.pack("<16I", *out)

4.3.4 XOR 암호화 및 카운터 증가

# 생성된 키스트림과 평문을 XOR
for i in range(block_size):
    ciphertext[i] = plaintext[i] ^ keystream[i]

# 블록마다 카운터 증가
counter++

4.4 파일 처리 아키텍처

DevMan의 파일 암호화 프로세스는 다음과 같습니다:

[파일 처리 과정]
1. 파일 열기 및 읽기
   ↓
2. CryptGenRandom 호출
   - 32바이트 ChaCha 키 생성
   - 8바이트 nonce 생성
   ↓
3. ChaCha State 초기화
   - Constant: "expand 32-byte k"
   - Key: 생성된 32바이트
   - Counter: 0
   - Nonce: 생성된 8바이트
   ↓
4. ChaCha8 블록 암호화
   - 4번의 더블 라운드
   - 키스트림 생성
   - XOR 연산
   ↓
5. 암호화된 데이터 쓰기
   ↓
6. 파일명 변경
   원본.확장자 → 원본.확장자.devman

4.5 정적 분석

CSP 초기화

RSA-4096 공개키 임포트

pbData (RSA1 시그니처)

5MB 작업 버퍼 할당

크리티컬 섹션 동기화 (5초 대기)

CSP(암호화 컨텍스트) 획득 시도

디렉터리 스캔

파일 검색

디렉터리 건너뛰기 (”.”, “..”, 리파스 포인트)

디렉터리 화이트/블랙리스트 체크 (목록 난독화 → 런타임 시, 복호화)

파일 확장자 화이트/블랙리스트 체크 (목록 난독화 → 런타임 시, 복호화)

암호화 전략 선택

1. ChaCha8 키 생성 + RSA 메타데이터 생성

ChaCha 키 생성 (32바이트)

Nonce 생성 (8바이트)

ChaCha 상수 설정

카운터 초기화

파일명 메타데이터 저장

RSA 공개키로 메타데이터 암호화

2. 파일 열기

3. 시스템 파일 제외 (목록은 난독화 → 런타임 복호화)

4. 파일 크기 읽기 및 암호화 전략 선택 시작

전체 파일 암호화 (작은 파일, 특수 파일(.dll/.exe))

부분 암호화 (중간 파일)

Stride 암호화 (큰 파일)

암호화된 데이터 쓰기

5. 파일명 변경 (.infected 확장자 추가)

6. 키/IV 초기화

파일 암호화 (ChaCha8 + RSA 메타데이터)

ChaCha8 상태 초기화

ChaCha8 암호화 (4회 반복)

카운터 증가 (64바이트 블록 단위)

암호화된 데이터 쓰기

5. 복호화 기술 분석 (Decryption Strategy)

5.1 복호화 가능성 분석

DevMan 랜섬웨어는 다음과 같은 특성으로 인해 완벽한 복호화가 가능합니다:

키 생성 시점 취약점 : CryptGenRandom API 호출 시 생성되는 평문 키를 API 후킹으로 실시간 캡처 가능
메모리 덤프 가능성 : 암호화 진행 중 프로세스 메모리에 평문 키가 존재
파일별 독립 암호화 : 각 파일마다 별도의 키를 사용하므로, 해당 키만 있으면 개별 파일 복호화 가능
단순한 암호화 구조 : 추가적인 메타데이터나 RSA 암호화 없이 ChaCha8만 사용

5.2 ChaCha8 키 복구 메커니즘

DevMan의 암호학적 약점은 CryptGenRandom API 호출 시점에 생성되는 32바이트 키와 8바이트 nonce가 평문으로 메모리에 존재한다는 점입니다.

[취약점 구조]
CryptGenRandom API 호출
         ↓
   평문 키 생성 (32B)
         ↓
  ★ API 후킹 지점 ★  ← 키 캡처 가능!
         ↓
  ChaCha State 초기화
         ↓
   파일 암호화 수행

5.3 ChaCha8 복호화 스크립트 개발

캡처한 키 정보를 활용하여 Python 기반 ChaCha8 복호화 스크립트를 개발했습니다.

스크립트 주요 기능:

API 후킹 로그 파일 파싱 (키/nonce 추출)
ChaCha8 state 초기화 및 키스트림 생성
XOR 연산을 통한 복호화 수행
파일 시그니처 검증 (매직 넘버)
원본 파일 복원 및 저장

핵심 복호화 로직:

# 파일 시그니처 정의
COMMON_SIGNATURES = {
    b"%PDF-": "pdf",
    b"\x89PNG\r\n\x1a\n": "png",
    b"PK\x03\x04": "zip",
    b"MZ": "exe",
    b"\xff\xd8\xff": "jpg",
}

def rotl32(v, n):
    """32비트 좌측 순환 시프트"""
    return ((v << n) & 0xffffffff) | (v >> (32 - n))

def quarter_round(s, a, b, c, d):
    """ChaCha Quarter Round 연산"""
    s[a] = (s[a] + s[b]) & 0xffffffff
    s[d] ^= s[a]; s[d] = rotl32(s[d], 16)
    s[c] = (s[c] + s[d]) & 0xffffffff
    s[b] ^= s[c]; s[b] = rotl32(s[b], 12)
    s[a] = (s[a] + s[b]) & 0xffffffff
    s[d] ^= s[a]; s[d] = rotl32(s[d], 8)
    s[c] = (s[c] + s[d]) & 0xffffffff
    s[b] ^= s[c]; s[b] = rotl32(s[b], 7)

def chacha_block(key32, counter, nonce64, rounds=8):
    """ChaCha8 블록 생성"""
    constants = b"expand 32-byte k"
    key_words = list(struct.unpack("<8I", key32))
    nonce_words = list(struct.unpack("<2I", nonce64))
    
    # State 초기화
    state = [
        struct.unpack("<I", constants[i:i+4])[0] 
        for i in range(0, 16, 4)
    ] + key_words + [counter & 0xffffffff, 
                      (counter >> 32) & 0xffffffff] + nonce_words
    
    working = state.copy()
    
    # 4번의 더블 라운드
    for _ in range(rounds // 2):
        # Column rounds
        quarter_round(working, 0, 4, 8, 12)
        quarter_round(working, 1, 5, 9, 13)
        quarter_round(working, 2, 6, 10, 14)
        quarter_round(working, 3, 7, 11, 15)
        # Diagonal rounds
        quarter_round(working, 0, 5, 10, 15)
        quarter_round(working, 1, 6, 11, 12)
        quarter_round(working, 2, 7, 8, 13)
        quarter_round(working, 3, 4, 9, 14)
    
    out = [(working[i] + state[i]) & 0xffffffff for i in range(16)]
    return struct.pack("<16I", *out)

def chacha_keystream(key32, nonce64, rounds, length):
    """키스트림 생성"""
    ks = bytearray()
    ctr = 0
    while len(ks) < length:
        ks.extend(chacha_block(key32, ctr, nonce64, rounds))
        ctr += 1
    return bytes(ks[:length])

def parse_hook_log(path):
    """로그 파일에서 키-nonce 쌍 추출"""
    text = Path(path).read_text(errors="ignore")
    pairs = []
    current_key = None
    
    for line in text.split('\n'):
        if 'Data: ' in line:
            match = re.search(r'Data:\s+([0-9a-fA-F]+)', line)
            if match:
                data_hex = match.group(1).lower()
                if len(data_hex) == 64:  # 32바이트 키
                    current_key = data_hex
                elif len(data_hex) == 16 and current_key:  # 8바이트 nonce
                    pairs.append((current_key, data_hex))
                    current_key = None
    return pairs

def decrypt_file(encrypted_file, key_hex, nonce_hex, output_file):
    """파일 복호화"""
    # 키와 nonce를 바이너리로 변환
    key = unhexlify(key_hex)
    nonce = unhexlify(nonce_hex)
    
    # 암호화된 데이터 읽기
    ciphertext = Path(encrypted_file).read_bytes()
    
    # 키스트림 생성 (ChaCha8, 8라운드)
    keystream = chacha_keystream(key, nonce, rounds=8, length=len(ciphertext))
    
    # XOR 복호화
    plaintext = bytes(a ^ b for a, b in zip(ciphertext, keystream))

5.4 무결성 검증

복구된 파일의 유효성을 판단하기 위해 파일 헤더 시그니처(매직 넘버)를 검증합니다.

파일 유형	매직 넘버 (Hex)	설명
JPG	FF D8 FF	JPEG 이미지 파일
PNG	89 50 4E 47 0D 0A 1A 0A	PNG 이미지 파일
PDF	25 50 44 46	PDF 문서 파일
EXE/DLL	4D 5A (MZ)	Windows 실행 파일
ZIP/DOCX	50 4B 03 04	압축 파일 및 MS Office
ELF	7F 45 4C 46	Linux 실행 파일

6. 요약 및 결론 (Conclusion)

6.1 최종 평가

DevMan 랜섬웨어는 ChaCha8 스트림 암호화를 사용하는 경량화된 악성코드입니다. DragonForce의 변종으로 추정되지만, RSA 하이브리드 방식이나 복잡한 메타데이터 저장 없이 단순화된 암호화 구조를 가지고 있습니다. 그러나 키 생성 과정에서 CryptGenRandom API를 직접 호출하는 구조적 취약점으로 인해, API 후킹을 통한 실시간 키 캡처가 가능하며, 이를 활용한 완벽한 복호화가 실증되었습니다.

[취약점 요약]
CryptGenRandom API 호출
         ↓
   평문 키 생성 (32B + 8B)
         ↓
  ★ API 후킹 지점 ★  ← 키 캡처 가능!
         ↓
  ChaCha State 초기화
         ↓
   파일 암호화 수행
         ↓
  .devman 확장자 추가

6.2 대응 가이드

6.2.1 예방적 조치

API 모니터링 강화
- CryptGenRandom, BCryptGenRandom 등 암호화 API 호출을 실시간 모니터링하는 EDR 솔루션 배치
- 의심스러운 대량의 난수 생성 패턴 탐지
행위 기반 탐지
- 대량 파일 접근 패턴 탐지
- .devman 확장자 추가 행위 차단
파일 시스템 보호
- 실시간 백업 시스템 구축 (VSS, 증분 백업)
- 중요 디렉터리에 대한 접근 제어 강화

6.2.2 사후 대응

초동 조치
- 감염 발견 즉시 시스템 격리 (네트워크 차단)
- 시스템을 종료하지 말고 메모리 덤프(Full Memory Dump) 수행
- 프로세스 메모리에서 CryptGenRandom 생성 키 추출 시도
키 복구 시도
- API 후킹 도구(Frida, Detours 등)를 사용하여 CryptGenRandom 호출 로그 확보
- 메모리 포렌식을 통한 평문 키 탐색
- 로그 파일 또는 메모리 덤프에서 32바이트 키 패턴 추출
복호화 수행
- 본 보고서에서 제공하는 ChaCha8 복호화 스크립트 활용
- 추출한 키/nonce로 암호화된 파일 복원
- 매직 넘버 검증을 통한 복호화 성공 여부 확인

6.3 기술적 특징 요약

항목	세부 내용
암호화 알고리즘	ChaCha8 (4번의 더블 라운드)
키 관리	파일별 독립 32바이트 키 + 8바이트 nonce
암호화 전략	단순 전체 파일 암호화
메타데이터	없음 (키 정보 별도 저장 안함)
확장자	.devman
복호화 가능성	API 후킹 또는 메모리 덤프로 키 확보 시 100% 복구 가능

6.4 결론

DevMan 랜섬웨어는 ChaCha8을 사용하는 단순화된 암호화 구조를 가진 악성코드입니다. RSA 하이브리드 방식이나 복잡한 메타데이터 없이 순수 ChaCha8만 사용하여 빠른 암호화 속도를 달성하지만, 이는 동시에 복호화를 더 쉽게 만드는 요인이 됩니다. API 후킹을 통해 평문 키를 확보할 경우 즉시 복호화가 가능하며, 본 분석에서 개발된 복호화 도구는 DevMan 감염 피해 복구에 직접 활용될 수 있습니다. 향후 랜섬웨어 대응을 위해서는 암호화 API 모니터링 강화와 실시간 메모리 포렌식 체계 구축이 필수적입니다.

DragonForce 랜섬웨어 분석 보고서

geonwoo9643 — Tue, 3 Feb 2026 18:18:20 +0900

1. 개요 (Overview)

1.1 분석 배경

DragonForce 랜섬웨어는 2025년 초부터 활발히 유포되고 있는 악성코드로, ChaCha8 스트림 암호화와 RSA 공개키 암호화를 결합한 하이브리드 암호화 방식을 채택하고 있습니다. 특히 멀티스레드 기반의 고속 암호화 엔진을 탑재하여 대량의 파일을 신속하게 암호화하며, 파일 크기와 타입에 따라 차별화된 암호화 전략을 적용합니다. 본 보고서는 DragonForce의 암호학적 구조를 정밀 분석하고, API 후킹을 통한 실시간 키 추출 기법과 복호화 전략을 제시합니다.

1.2 핵심 요약

고성능 멀티스레드 아키텍처 : CreateThread API를 반복 호출하여 다수의 워커 스레드를 생성하고, 병렬 처리를 통해 암호화 속도를 극대화합니다.
ChaCha8 스트림 암호화 : 4번의 더블 라운드를 수행하는 경량화된 ChaCha8 알고리즘을 사용하여, 성능과 보안성의 균형을 추구합니다. 각 파일마다 고유한 32바이트 키와 8바이트 nonce를 생성합니다.
차별화된 암호화 전략 : 파일 크기와 타입에 따라 전체 파일 암호화, 선택적 청크 암호화, 헤더만 암호화 등 세 가지 방식을 선택적으로 적용합니다.
완벽한 복호화 가능성 : CryptGenRandom API 호출 시점에 생성되는 평문 키를 API 후킹으로 실시간 캡처할 경우, RSA 개인키 없이도 완벽한 복호화가 가능합니다. 본 분석에서 개발한 복호화 스크립트를 통해 실증적으로 검증되었습니다.

2. 식별 정보 (Identification)

Malware Family: DragonForce
Filetype: PE32 (Windows Executable)
Hash (SHA256): c844d02c91d5e6dc293de80085ad2f69b5c44bc46ec9fdaa4e3efbda062c871c
Extension: .dragonforce_encrypted
Target: Windows 기반 시스템

3. 분석 환경 및 도구 (Tools)

구분	도구명 (Tool)	용도 (Purpose)
정적 분석	IDA Pro	ChaCha8 구현 루틴 및 암호화 로직 분석
동적 분석	CryptGenRandom API Hooking (x86)	실시간 키 및 nonce 추출
행위 분석	Process Monitor	파일 I/O 및 멀티스레드 행위 추적
검증 도구	Python	ChaCha8 복호화 스크립트 개발 및 PoC

4. 암호화 기술 분석 (Technical Analysis)

4.1 전체 암호화 워크플로우

DragonForce는 고성능 멀티스레딩 모델을 기반으로 다음과 같은 5단계 프로세스를 거칩니다.

멀티스레드 생성 : WinMain에서 CreateThread API를 반복 호출하여 다수의 워커 스레드(StartAddress) 생성
키 및 Nonce 생성 : CryptGenRandom API를 통해 파일별로 고유한 32바이트 ChaCha 키와 8바이트 nonce를 생성
ChaCha State 초기화 : 생성된 키와 nonce로 ChaCha state를 초기화하고 카운터를 0으로 설정
차별화된 파일 암호화 : 파일 크기 및 타입에 따라 전체/부분/헤더 암호화 전략을 선택적으로 적용
메타데이터 저장 : ChaCha 키, nonce, 파일명 정보를 RSA 공개키로 암호화하여 파일 footer에 추가

4.2 키 생성 및 관리 (Key Generation)

4.2.1 CryptGenRandom을 통한 난수 생성

DragonForce는 Windows CryptoAPI의 CryptGenRandom 함수를 사용하여 암호학적으로 안전한 난수를 생성합니다.

// 각 파일마다 고유한 키와 nonce 생성
CryptGenRandom(hProv, 32, chacha_key);    // 32바이트 ChaCha Key
CryptGenRandom(hProv, 8, chacha_nonce);   // 8바이트 ChaCha Nonce

4.2.2 ChaCha State 초기화

생성된 키와 nonce를 사용하여 ChaCha state를 초기화합니다.

Constant: "expand 32-byte k" (ChaCha 표준 상수)
Key: CryptGenRandom으로 생성한 32바이트 난수
Counter: 0으로 초기화 (블록마다 1씩 증가)
Nonce: CryptGenRandom으로 생성한 8바이트 난수

ChaCha State 구조 (64바이트):

Constant (16B)

Key (32B)

Counter (8B)

Nonce (8B)

4.2.3 메타데이터 생성 및 RSA 암호화

파일 복호화에 필요한 정보를 메타데이터로 구성하여 RSA 공개키로 암호화합니다.

메타데이터 구조 (→ RSA 공개키로 암호화 → 파일 footer에 추가) :

ChaCha Key (32B)

ChaCha Nonce (8B)

파일명 길이 (4B)

파일명 (Variable)

공격자는 RSA 개인키를 통해 이 메타데이터를 복호화하여 각 파일의 ChaCha 키를 복구할 수 있습니다.

4.3 파일 처리 및 I/O 아키텍처

4.3.1 CreateThread 기반 멀티스레드 암호화

[WinMain]
    ├─> CreateThread (Worker Thread 1) → StartAddress
    ├─> CreateThread (Worker Thread 2) → StartAddress
    ├─> CreateThread (Worker Thread 3) → StartAddress
    └─> CreateThread (Worker Thread N) → StartAddress

[StartAddress]
    └─> 파일 시스템 순회
        └─> 대상 파일 발견
            └─> 파일 암호화 수행

4.3.2 파일 암호화 메인 로직

다음의 순서로 파일 암호화를 수행합니다:

키 및 Nonce 생성: CryptGenRandom 호출
ChaCha State 초기화: 키, nonce, 카운터 설정
파일 크기/타입 판별: 암호화 전략 선택
ChaCha8 블록 암호화: 실제 암호화 수행
메타데이터 기록: RSA로 암호화된 메타데이터를 footer에 추가

4.3.3 파일 크기 및 타입에 따른 차별화된 암호화 전략

DragonForce는 효율성을 위해 파일 크기와 타입에 따라 세 가지 암호화 방식을 선택적으로 적용합니다.

암호화 방식	대상 파일
전체 파일 암호화	작은 파일 (< 1MB)
선택적 청크 암호화	큰 파일 (≥ 1MB, 성능 최적화)
헤더만 암호화	특정 파일 타입 (미디어 파일 등)

암호화 프로세스 :

SetFilePointerEx (파일 포인터 이동)
    ↓
ReadFile (데이터 읽기)
    ↓
Encryption (ChaCha8 블록 암호화)
    ↓
WriteFile (암호화된 데이터 쓰기)
    ↓
파일명 변경 (원본.확장자 → 원본.확장자.dragonforce_encrypted)

4.4 정적 분석

멀티스레드 암호화 (CreateThread)

작업자 스레드 함수 (암호화)

pbData (RSA1 시그니처)

파일 암호화 실행 함수

스레드 시작
    ↓
Crypto API 초기화
    ↓
RSA 공개키 임포트 (CryptImportKey)
- pbData : 4096바이트 RSA 공개키
- "RSA1" 시그니처 확인됨
    ↓
5MB 암호화 버퍼 할당 (VirtualAlloc)
    ↓
무한 루프 시작
    ↓
┌──────────────────────────────┐
│ 크리티컬 섹션 진입            │
│ (EnterCriticalSection)        │
└──────────────────────────────┘
    ↓
작업 큐에서 파일 항목 가져오기
    ↓ 
큐가 비어있음? ──Yes─→ 5초 대기 후 재시도
    ↓ No
큐에서 항목 제거 (연결 리스트 업데이트)
    ↓
┌──────────────────────────────┐
│ 크리티컬 섹션 탈출            │
│ (LeaveCriticalSection)        │
└──────────────────────────────┘
    ↓
종료 플래그 확인? ──Yes─→ 스레드 종료
    ↓ No
파일 경로 처리
    ↓
파일 암호화 실행 함수 호출
- RSA 공개키로 ChaCha 키/Nonce 암호화
- select_encryption_strategy 호출
- 파일 크기별 암호화 전략 실행
    ↓
작업 항목 메모리 해제 (free)
    ↓
무한 루프 계속

랜덤 키/Nonce 생성 (CryptGenRandom)

ChaCha State 초기화

ChaCha8 블록 암호화

1. ChaCha8 키스트림 생성

ChaCha8은 일반적인 ChaCha20의 10번 더블 라운드 대신, 4번의 더블 라운드를 수행하여 성능을 최적화한 변형입니다.

ChaCha8 라운드 구조:
┌─────────────────────────────────┐
│    Initial State (64 bytes)     │
│  [Constant | Key | Ctr | Nonce] │
└─────────────────────────────────┘
            ↓
    ┌───────────────┐
    │ Double Round  │  ← 4번 반복 (ChaCha8)
    │ (QR 함수 8회) │
    └───────────────┘
            ↓
┌─────────────────────────────────┐
│      Keystream (64 bytes)       │
└─────────────────────────────────┘

2. ChaCha 라운드 연산 (Quarter Round)

Quarter Round (a, b, c, d):
    a += b; d ^= a; d <<<= 16;
	    c += d; b ^= c; b <<<= 12;
    a += b; d ^= a; d <<<= 8;
    c += d; b ^= c; b <<<= 7;

3. XOR 암호화 및 카운터 증가

*// 생성된 키스트림과 평문을 XOR*

for (i = 0; i < block_size; i++) {
    ciphertext[i] = plaintext[i] ^ keystream[i];
}

*// 블록마다 카운터 증가*

counter++;

메타데이터 생성 및 RSA 암호화

메타데이터 구조체 생성

RSA 공개키로 메타데이터 암호화

암호화된 메타데이터를 파일 footer에 기록

파일 처리 전체 흐름

파일 열기 및 크기 확인

암호화 전략 선택

전체 암호화 (작은 파일)

헤더만 암호화 (중간 크기 파일)

청크 단위 선택 암호화 (큰 파일)

암호화된 데이터 파일에 쓰기

파일명 변경 (.dragonforce_encrypted 추가)

[파일 처리 과정]
1. 파일 열기 및 크기 확인
   ↓
2. CryptGenRandom 호출
   - 32바이트 ChaCha 키 생성
   - 8바이트 nonce 생성
   ↓
3. ChaCha State 초기화
   - Constant: "expand 32-byte k"
   - Key: 생성된 32바이트
   - Counter: 0
   - Nonce: 생성된 8바이트
   ↓
4. 파일 크기/타입에 따라 암호화 전략 선택
   - 작은 파일: 전체 암호화
   - 큰 파일: 선택적 청크 암호화
   - 특정 타입: 헤더만 암호화
   ↓
5. ChaCha8 블록 암호화
   - 4번의 더블 라운드
   - 키스트림 생성
   - XOR 연산
   ↓
6. 메타데이터 생성 및 암호화
   - [Key | Nonce | 파일명 길이 | 파일명]
   - RSA 공개키로 암호화
   - 파일 footer에 추가
   ↓
7. 파일명 변경
   원본.확장자 → 원본.확장자.dragonforce_encrypted

함수 호출 관계도 (Call Graph)

5. 복호화 기술 분석 (Decryption Strategy)

5.1 복호화 가능성 분석

DragonForce 랜섬웨어는 다음과 같은 특성으로 인해 완벽한 복호화가 가능합니다:

키 생성 시점 취약점 : CryptGenRandom API 호출 시 생성되는 평문 키를 API 후킹으로 실시간 캡처 가능
메모리 덤프 가능성 : 암호화 진행 중 프로세스 메모리에 평문 키가 존재
파일별 독립 암호화 : 각 파일마다 별도의 키를 사용하므로, 해당 키만 있으면 개별 파일 복호화 가능
RSA 개인키 불필요 : API 후킹으로 평문 키를 직접 확보하므로, 공격자의 RSA 개인키 없이도 복호화 가능

5.2 ChaCha8 키 복구 메커니즘

DragonForce의 암호학적 약점은 CryptGenRandom API 호출 시점에 생성되는 32바이트 키와 8바이트 nonce가 평문으로 메모리에 존재한다는 점입니다.

# API 후킹 로그에서 키 추출
def extract_keys_from_log(log_file):
    keys = []
    with open(log_file, 'r') as f:
        for line in f:
            if "Length: 32 bytes" in line:
                # 다음 줄에서 키 추출
                key_line = next(f)
                key = extract_hex(key_line)  # "Data: ..." 파싱
                
                # 이어서 nonce 추출 (다음 32바이트 로그 항목)
                nonce_line1 = next(f)
                nonce_line2 = next(f)
                nonce = extract_hex(nonce_line2)
                
                keys.append((key, nonce))
    return keys

5.3 ChaCha8 복호화 스크립트 개발

캡처한 키 정보를 활용하여 Python 기반 ChaCha8 복호화 스크립트를 개발했습니다.

스크립트 주요 기능:

API 후킹 로그 파일 파싱 (키/nonce 추출)
암호화 파일의 footer에서 메타데이터 추출 (선택적)
ChaCha8 state 초기화 및 키스트림 생성
XOR 연산을 통한 복호화 수행
원본 파일 복원 및 저장

def chacha8_decrypt(ciphertext, key, nonce):
    """
    ChaCha8 복호화 (ChaCha20의 8라운드 변형)
    """
    # 1. ChaCha State 초기화
    state = initialize_chacha_state(key, nonce, counter=0)
    
    # 2. 블록 단위 복호화
    plaintext = bytearray()
    block_size = 64  # ChaCha는 64바이트 블록
    
    for block_idx in range(0, len(ciphertext), block_size):
        # 키스트림 생성 (4번의 더블 라운드)
        keystream = chacha8_block(state, counter=block_idx // block_size)
        
        # XOR 복호화
        block = ciphertext[block_idx:block_idx + block_size]
        for i in range(len(block)):
            plaintext.append(block[i] ^ keystream[i])
    
    return bytes(plaintext)

def chacha8_block(initial_state, counter):
    """
    ChaCha8 키스트림 블록 생성 (4번의 더블 라운드)
    """
    state = initial_state.copy()
    state[12] = counter  # 카운터 설정
    
    working_state = state.copy()
    
    # 4번의 더블 라운드 (총 8번의 라운드)
    for _ in range(4):
        # Column round
        quarter_round(working_state, 0, 4, 8, 12)
        quarter_round(working_state, 1, 5, 9, 13)
        quarter_round(working_state, 2, 6, 10, 14)
        quarter_round(working_state, 3, 7, 11, 15)
        
        # Diagonal round
        quarter_round(working_state, 0, 5, 10, 15)
        quarter_round(working_state, 1, 6, 11, 12)
        quarter_round(working_state, 2, 7, 8, 13)
        quarter_round(working_state, 3, 4, 9, 14)
    
    # Add initial state
    for i in range(16):
        working_state[i] = (working_state[i] + state[i]) & 0xFFFFFFFF
    
    # Convert to bytes (keystream)
    return state_to_bytes(working_state)

5.4 무결성 검증

복구된 파일의 유효성을 판단하기 위해 파일 헤더 시그니처(매직 넘버)를 검증합니다.

파일 유형	매직 넘버 (Hex)	설명
JPG	FF D8 FF	JPEG 이미지 파일
PNG	89 50 4E 47 0D 0A 1A 0A	PNG 이미지 파일
GIF	47 49 46 38	GIF 이미지 파일
PDF	25 50 44 46	PDF 문서 파일
EXE/DLL	4D 5A (MZ)	Windows 실행 파일
ZIP/DOCX	50 4B 03 04	압축 파일 및 MS Office
DOC (Old)	D0 CF 11 E0	MS Office 구버전
TXT	가독 문자 비중 70% 이상	텍스트 파일 판별 로직

def verify_decryption(decrypted_data, expected_filetype):
    """
    복호화된 데이터의 매직 넘버 검증
    """
    magic_numbers = {
        'jpg': bytes([0xFF, 0xD8, 0xFF]),
        'png': bytes([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]),
        'pdf': bytes([0x25, 0x50, 0x44, 0x46]),
        'exe': bytes([0x4D, 0x5A]),
        'zip': bytes([0x50, 0x4B, 0x03, 0x04]),
        # ... 추가 파일 타입
    }
    
    if expected_filetype in magic_numbers:
        expected_magic = magic_numbers[expected_filetype]
        return decrypted_data.startswith(expected_magic)
    
    return True  # 알 수 없는 타입은 검증 생략

6. 요약 및 결론 (Conclusion)

6.1 최종 평가

DragonForce 랜섬웨어는 ChaCha8 스트림 암호화와 RSA 하이브리드 방식, 멀티스레드 기반 고속 처리를 특징으로 하는 정교한 악성코드입니다. 그러나 키 생성 과정에서 CryptGenRandom API를 직접 호출하는 구조적 취약점으로 인해, API 후킹을 통한 실시간 키 캡처가 가능하며, 이를 활용한 완벽한 복호화가 실증되었습니다.

[취약점 요약]
CryptGenRandom API 호출
         ↓
   평문 키 생성 (32B)
         ↓
  ★ API 후킹 지점 ★  ← 키 캡처 가능!
         ↓
  ChaCha State 초기화
         ↓
   파일 암호화 수행

6.2 대응 가이드

6.2.1 예방적 조치

API 모니터링 강화
- CryptGenRandom, BCryptGenRandom 등 암호화 API 호출을 실시간 모니터링하는 EDR 솔루션 배치
- 의심스러운 대량의 난수 생성 패턴 탐지
행위 기반 탐지
- 멀티스레드 기반의 대량 파일 접근 패턴 탐지
- .dragonforce_encrypted 확장자 추가 행위 차단
- 파일 footer에 메타데이터 기록 행위 모니터링
파일 시스템 보호
- 실시간 백업 시스템 구축 (VSS, 증분 백업)
- 중요 디렉터리에 대한 접근 제어 강화

6.2.2 사후 대응

초동 조치
- 감염 발견 즉시 시스템 격리 (네트워크 차단)
- 시스템을 종료하지 말고 메모리 덤프(Full Memory Dump) 수행
- 프로세스 메모리에서 CryptGenRandom 생성 키 추출 시도
키 복구 시도
- API 후킹 도구(Frida, Detours 등)를 사용하여 CryptGenRandom 호출 로그 확보
- 메모리 포렌식을 통한 평문 키 탐색
- 로그 파일 또는 메모리 덤프에서 32바이트 키 패턴 추출
복호화 수행
- 본 보고서에서 제공하는 ChaCha8 복호화 스크립트 활용
- 추출한 키/nonce로 암호화된 파일 복원
- 매직 넘버 검증을 통한 복호화 성공 여부 확인

6.3 기술적 특징 요약

항목	세부 내용
암호화 알고리즘	ChaCha8 (4번의 더블 라운드) + RSA (메타데이터)
키 관리	파일별 독립 32바이트 키 + 8바이트 nonce
암호화 전략	파일 크기/타입에 따라 전체/부분/헤더 암호화 선택
멀티스레딩	CreateThread 기반 워커 스레드 병렬 처리
메타데이터	RSA로 암호화된 키 정보를 파일 footer에 저장
확장자	.dragonforce_encrypted
복호화 가능성	API 후킹 또는 메모리 덤프로 키 확보 시 100% 복구 가능

6.4 결론

DragonForce 랜섬웨어는 ChaCha8과 RSA를 결합한 하이브리드 암호화 방식과 멀티스레드 기반 고속 암호화를 특징으로 하는 위협적인 악성코드입니다. 그러나 키 생성 과정의 구조적 취약점으로 인해, 적절한 대응 절차(API 후킹, 메모리 포렌식)를 통해 평문 키를 확보할 경우 RSA 개인키 없이도 완벽한 복호화가 가능합니다. 분석을 통해 개발된 ChaCha8 복호화 도구는 DragonForce 감염 피해 복구에 직접 활용될 수 있으며, 유사한 ChaCha 기반 랜섬웨어 대응에도 응용 가능합니다. 향후 랜섬웨어 대응을 위해서는 암호화 API 모니터링 강화와 실시간 메모리 포렌식 체계 구축이 필수적입니다.

Lynx 랜섬웨어 분석 보고서

geonwoo9643 — Thu, 1 Jan 2026 23:24:24 +0900

1. 개요 (Overview)

1.1 분석 배경

Lynx 랜섬웨어는 2024년 중반부터 활동이 두드러진 악성코드로, INC Ransom → LYNX → Sinobi로 이어지는 리브랜딩 계보의 핵심 변종입니다. 특히 Sinobi와 암호화 엔진을 공유하며, 단순 대칭키 암호화를 넘어 ECDH(Curve25519) 기반의 정교한 키 교환 메커니즘을 채택하고 있습니다. 본 보고서는 Lynx의 암호학적 아키텍처를 정밀 분석하고, 세션 키 생성 과정의 취약점을 이용한 데이터 복구 전략을 제안합니다.

1.2 핵심 요약

고도화된 키 교환 아키텍처 : RSA 기반의 단순 구조를 탈피하여, Curve25519 타원 곡선 암호와 SHA-512 KDF(Key Derivation Function)를 결합한 세션 키 생성 모델을 운용합니다.
고성능 암호화 엔진 : AES-128 CTR(Counter) 모드를 사용하여 병렬 처리를 지원하며, 파일 끝에 116바이트의 독자적인 메타데이터 마커를 삽입합니다.
조건부 복구 가능성 : 공격자의 RSA 개인키가 없더라도, 난수 생성 API(CryptGenRandom) 호출 시점에 생성된 32바이트 클라이언트 시드를 메모리 포렌식으로 확보할 경우 완벽한 복구가 가능합니다.

2. 식별 정보 (Identification)

Malware Family: Lynx (INC Ransom / Sinobi 계보)
Filetype: PE32 (Windows Executable)
Hash (SHA256): 0315dbb793f855f154aa8d227151f1098bd9b580a4f85064648b85bac1321663
Extension: .LYNX
Ransom Note: README.txt
Target: Windows Enterprise Environment

3. 분석 환경 및 도구 (Tools)

구분	도구명 (Tool)	용도 (Purpose)
정적 분석	IDA Pro	Curve25519 Montgomery Ladder 및 SHA-512 구현 루틴 분석
동적 분석	x64dbg	CryptGenRandom 호출 시점의 32바이트 난수(시드) 추출
행위 분석	Process Monitor	파일 I/O 완료 포트(IOCP) 및 워커 스레드 행위 추적
검증 도구	Python	cryptography 라이브러리를 이용한 ECDH 키 파생 및 복구 PoC

4. 암호화 기술 분석 (Technical Analysis)

4.1 전체 암호화 워크플로우

Lynx는 고성능 멀티스레딩 모델을 기반으로 다음과 같은 4단계 프로세스를 거칩니다.

시드 생성 : Windows CryptoAPI의 CryptGenRandom을 통해 32바이트 클라이언트 시드를 생성합니다.
ECDH 키 교환 : 생성된 시드를 Curve25519 표준에 맞게 Clamping한 후, 하드코딩된 서버 공개키와 연산하여 공유 비밀(Shared Secret)을 도출합니다.
키 파생(KDF) : 공유 비밀을 SHA-512로 해싱하여 AES-128 키(16B)와 초기 카운터(16B)를 추출합니다.
병렬 암호화 : AES-128 CTR 모드로 데이터를 암호화하며, I/O 완료 포트(IOCP)를 통해 워커 스레드가 1MB 청크 단위로 처리합니다.

4.2 키 생성 및 관리 (Key Generation)

4.2.1 Curve25519 스칼라 포맷팅 (Clamping)

Lynx는 생성된 32바이트 난수를 그대로 사용하지 않고, RFC 7748 표준에 따른 비트 조작 과정을 거쳐 타원 곡선 연산의 안전성을 확보합니다.

// IDA Pro 정적 분석 데이터 기반 재구성
client_private[0] &= 0xF8;      // 하위 3비트 클리어 (Small Subgroup 공격 방지)
client_private[31] &= 0x7F;     // 최상위 비트 클리어
client_private[31] |= 0x40;     // 비트 6 설정 (표준 X25519 형식)

4.2.2 SHA-512 기반 키 추출 결함

생성된 공유 비밀은 SHA-512 해시 함수를 통해 확장됩니다. 이 과정에서 AES 키와 CTR 카운터가 인접하게 배치됩니다.

AES-128 Key : hash_output[0:16]
CTR Counter : hash_output[16:32] (Big-endian)

4.3 파일 처리 및 I/O 아키텍처

Lynx는 대규모 엔터프라이즈 환경을 타겟팅하므로, 효율적인 파일 처리를 위해 OVERLAPPED I/O와 워커 스레드 모델을 사용합니다.

작은 파일 (Case 2) : 직접 메타데이터를 삽입하고 즉시 처리.
큰 파일 (Case 3) : 매직 바이트 체크 후 IO 완료 포트에 큐잉하여 백그라운드에서 병렬 암호화.
메타데이터 삽입 : 암호화가 완료된 파일 끝에 클라이언트 공개키와 식별 문자열("LYNX")을 포함한 116바이트를 추가 기록합니다.

4.4 정적 분석

랜덤 키 생성 (32바이트)

Curve25519 키 클램핑

ECDH 키 교환 (공유 비밀 생성)

공격자 공개키 하드코딩

SHA-512 Hash 함수 (키 파생)

SHA-512 업데이트 함수

SHA-512 압축 함수

패딩 추가 및 해시 출력 (64바이트)

AES 키 확장 (10라운드)

AES 암호화 (AES-128-CTR)

파일 암호화

1. ECDH: shared_secret = curve25519(private_key, attacker_public_key)
2. KDF: hash = SHA512(shared_secret)  # 64바이트
3. 키 추출:
   - aes_key = hash[0:16]      # AES-128 마스터 키
   - counter = hash[16:32]     # CTR 초기 카운터
4. 키 확장: expanded_key = aes128_key_expansion(aes_key)  # 176바이트
5. 암호화: ciphertext = AES-128-CTR(plaintext, expanded_key, counter)
   - 1MB 청크 단위 처리
   - 마지막 116바이트는 암호화하지 않음
6. 메타데이터: 파일 끝에 116바이트 추가 (공개키, 해시, "LYNX")
7. 파일명 변경: 원본.확장자 → 원본.확장자.LYNX

파일 처리

[파일 처리 과정]
1. 파일 열기 및 크기 확인
   ↓
2. ECDH 키 교환
   - 랜덤 개인키 생성
   - 공유 비밀 계산
   - SHA-512로 키 파생
   ↓
3. AES 키 준비
   - 마스터 키: hash[0:16]
   - CTR 카운터: hash[16:32]
   - 확장 키: 176바이트
   ↓
4. OVERLAPPED 구조체 구성
   - 파일 정보
   - 암호화 키/카운터
   - 메타데이터 (116바이트)
   ↓
5. IO 완료 포트에 큐잉
   - 작은 파일: 케이스 2 (직접 메타데이터)
   - 큰 파일: 케이스 3 (매직 바이트 체크)
   ↓
6. 워커 스레드가 처리
   (encryption_worker_thread)
   
[출력]
원본파일명.LYNX (암호화된 파일)

5. 복호화 기술 분석 (Decryption Strategy)

5.1 세션 키 복구 메커니즘

Lynx의 유일한 암호학적 약점은 세션 키의 원천이 되는 32바이트 난수가 생성 직후 메모리에 평문으로 남거나, API 모니터링을 통해 탈취 가능하다는 점입니다.

def derive_lynx_keys(captured_seed):
    # 1. Clamping 수행 (X25519 표준)
    private_key = bytearray(captured_seed)
    private_key[0] &= 248
    private_key[31] = (private_key[31] & 127) | 64
    
    # 2. 공유 비밀 도출
    server_pub = x25519.X25519PublicKey.from_public_bytes(ATTACKER_PUB_KEY)
    shared_secret = x25519.X25519PrivateKey.from_private_bytes(private_key).exchange(server_pub)
    
    # 3. SHA-512 해시에서 키셋 분리
    kdf_output = hashlib.sha512(shared_secret).digest()
    return kdf_output[:16], kdf_output[16:32] # AES_KEY, COUNTER

5.2 무결성 검증

복구된 키의 유효성을 판단하기 위해 파일 헤더 시그니처를 대조합니다.

파일 유형	매직 넘버 (Hex)	설명
EXE/DLL	4D 5A	윈도우 실행 파일
ZIP/DOCX	50 4B 03 04	압축 파일 및 MS 오피스
PNG	89 50 4E 47	이미지 파일 시그니처

6. 요약 및 결론 (Conclusion)

6.1 최종 평가

Lynx 랜섬웨어는 Curve25519와 SHA-512를 결합하여 암호학적으로 매우 견고하게 설계되었습니다. 하지만 세션 키 생성의 기점이 되는 32바이트 시드 값이 메모리상에 노출될 수 있다는 점이 복구의 핵심 실마리입니다.

6.2 대응 가이드

초동 조치 : 감염 발생 즉시 시스템을 종료하지 말고, 메모리 덤프(Full Memory Dump)를 수행하여 CryptGenRandom에 의해 생성된 난수 시퀀스를 확보해야 합니다.
모니터링 강화 : Curve25519, SHA-512, AES-CTR 관련 암호 라이브러리를 빈번하게 호출하거나 파일 끝에 116바이트의 고정 데이터를 쓰는 프로세스를 탐지하도록 EDR 정책을 최적화하십시오.

Mamona 랜섬웨어 분석 보고서

geonwoo9643 — Thu, 1 Jan 2026 23:24:13 +0900

1. 개요 (Overview)

1.1 분석 배경

Mamona 랜섬웨어(Mammon 변종)는 비대칭 암호화 기술인 X25519와 커스텀 스트림 암호인 HC-128을 결합한 고도의 하이브리드 공격 도구다. 표준 알고리즘의 초기화 루틴을 의도적으로 변형하여 일반적인 복구 도구의 접근을 차단하며, 주로 기업 내부망을 타겟팅하여 데이터 복구를 무력화하는 기만술을 구사한다.

1.2 핵심 요약

하이브리드 암호 체계 : X25519를 통한 세션 키 교환과 고성능 HC-128 스트림 암호를 결합하여 보안성과 속도를 동시에 확보했다.
커스텀 암호 엔진 : 표준 HC-128의 초기화 절차를 SHA-256 기반 확장 루틴으로 재설계하여 분석가의 알고리즘 식별 및 복구 시도를 방해한다.
치명적 설계 결함 : 암호화의 원천이 되는 피해자 개인키가 CryptGenRandom API 호출 시점에 평문(Plaintext) 상태로 노출되는 결함이 존재하여, 메모리/로그 포렌식을 통한 데이터 복구가 가능하다.

2. 식별 정보 (Identification)

Malware Family: Mamona (Mammon Variant)
Filetype: PE32 (Windows Executable)
Hash (SHA256): c5f49c0f566a114b529138f8bd222865c9fa9fa95f96ec1ded50700764a1d4e7
Extension: .HAes 또는 .crypt
Target: Windows Environment

3. 분석 환경 및 도구 (Tools)

구분	도구명 (Tool)	용도 (Purpose)
정적 분석	IDA Pro	바이너리 디스어셈블리 및 커스텀 HC-128 로직 분석
행위 분석	Hooking Log	API 호출 모니터링 및 CryptGenRandom 기반 키 후보군 추출
검증 도구	Python	X25519/HC-128 복구 엔진 구현 및 자동 복호화 검증 (PoC)

4. 암호화 기술 분석 (Technical Analysis)

4.1 키 생성 및 관리

Mamona는 하이브리드 암호화 방식을 사용하여 매 실행 시 고유한 키를 생성한다.

X25519 기반 ECDH : 피해자 시스템에서 생성된 32바이트 임시 개인키와 공격자의 하드코딩된 공개키를 사용하여 Shared Secret(공유 비밀값)을 생성한다.
SHA-512 기반 KDF : 생성된 공유 비밀값을 SHA-512 해시 알고리즘에 통과시켜 64바이트 마스터 키를 도출한다.
대칭키 할당 : 마스터 키의 상위 32바이트는 HC-128 Key로, 하위 32바이트는 IV(초기화 벡터)로 할당되어 엔진에 로드된다.

4.2 커스텀 HC-128 엔진 분석

분석 방해를 위해 표준 HC-128의 내부를 다음과 같이 개조하였다.

변형된 초기화 (sub_4085E0) : Key와 IV를 state[1057..1072] 영역에 배치하며, 비트 길이를 명시적으로 기록하는 독자적인 구조를 가진다.
SHA-256 기반 테이블 확장 : 표준 Seed 초기화 대신 SHA-256의 메시지 확장 패턴(\sigma_0, \sigma_1 연산)을 적용하여 초기 P/Q 테이블(각 512워드)을 생성한다.
라운드 연산 및 스트림 생성 : 64회의 초기 라운드를 통해 테이블을 균질화한 후, 64바이트 단위의 키스트림을 생성하여 원본 데이터와 XOR한다.

4.3 파일 처리 및 부분 암호화 정책

I/O 효율성을 극대화하기 위해 파일 크기에 따라 암호화 범위를 차등 적용한다.

파일 크기 범위	암호화 정책	상세 방식
5MB 이하	전체 암호화	파일 전체 영역 파괴
5MB ~ 20MB	부분 스트라이핑	6개 구간에 대해 각 4KB씩 암호화
20MB 초과	고속 암호화	10MB 간격으로 4KB씩 암호화 (최대 70MB)

4.4 정적 분석

파일 암호화

Curve25519 키 교환 함수 (공유 비밀 생성)

SHA256 Hash 함수 (32바이트 마스터키 생성)

HC-128 내부 상태 배열 설정 (256-bit Key)

state[1057..1064] ← Key (8 words)
state[1065..1072] ← IV  (8 words)
state[1073]       ← Key 비트 길이 (256)
state[1074]       ← IV 비트 길이  (256)

HC-128 내부 상태 배열 설정 (256-bit IV) 및 P/Q 테이블 초기화 (각 512워드)

HC-128 스트림 암호화 함수

HC-128 키스트림 생성

파일 크기에 따른 암호화 방식

파일 크기	a3 = 1 (부분 암호화)	a3 = 0 (전체/퍼센트)
≤ 64 bytes	전체	전체
65B ~ 5MB	앞부분 10%	전체
5MB ~ 20MB	6개 구간 × 4KB	a2% (최대 70MB)
> 20MB	10MB 간격 × 4KB	a2% (최대 70MB)

5. 복호화 기술 분석 (Decryption Strategy)

5.1 복구 키 확보 방안

암호화의 핵심인 피해자 임시 개인키(32바이트)는 CryptGenRandom API 호출을 통해 생성된다. 이 시점에 후킹 도구나 메모리 덤프를 활용하면 평문 상태의 키 후보군을 확보할 수 있다. 확보된 개인키와 공격자의 공개키를 조합하면 세션 키를 재구성할 수 있다.

5.2 복호화 알고리즘 구현

확보된 키와 변형된 엔진 구조를 재현하여 데이터를 복구하는 핵심 로직이다.

# [코드 5-1] X25519 및 SHA-512 KDF를 통한 마스터 키 도출
def derive_keys(victim_priv, attacker_pub):
    # ECDH 공유 비밀값 생성
    shared = x25519(victim_priv, attacker_pub)
    # SHA-512 기반 Key(32B) / IV(32B) 분리
    master = hashlib.sha512(shared).digest()
    return master[:32], master[32:64]

# [코드 5-2] 커스텀 HC-128 복호화 엔진 구현 (PoC)
def decrypt_hc128(cipher, key_hex, iv_hex):
    state = alloc_state()
    # 변형된 초기화 루틴 (SHA-256 확장 적용)
    sub_4085E0(state, key_words, 256, 256)
    sub_408220(state, iv_words)
    
    # 파일 크기별 부분 암호화 길이에 맞춰 XOR 복호화
    dec_len = compute_partial_length(len(cipher))
    return sub_408650(state, cipher, dec_len)

5.3 무결성 검증 및 자동화 (Integrity Check)

추출된 여러 키 후보군 중 정답을 식별하기 위해 파일 헤더의 시그니처를 검증한다.

검증 대상 : PNG (\x89PNG), JPEG (\xFF\xD8\xFF), ZIP/Office (PK\x03\x04), PDF (%PDF)
프로세스 : 각 개인키 후보로 복호화 시도 → 헤더 매직 넘버 대조 → 일치 시 복구 확정.

6. 요약 및 결론 (Conclusion)

6.1 암호화 워크플로우

초기화 : 뮤텍스 생성 및 중복 실행 방지.
키 생성 : CryptGenRandom으로 피해자 개인키 생성 --> X25519 ECDH --> SHA-512 KDF.
암호화 : 커스텀 HC-128 엔진 가동, 파일 크기별 스트라이핑 정책 적용.
완료 : 확장자 변경(.HAes / .crypt) 및 결과 저장.

6.2 최종 평가

Mamona 랜섬웨어는 알고리즘 변조를 통해 분석을 어렵게 설계하였으나, 키 생성 과정에서의 개인키 노출이라는 결정적인 설계 결함을 가지고 있다. 침해 사고 발생 시 시스템을 재부팅하지 않고 후킹 로그 또는 메모리 덤프를 확보한다면, 본 보고서에서 제시한 자동 복호화 모델을 통해 원본 데이터를 온전히 복원할 수 있다.

WannaCry 랜섬웨어 분석 보고서

geonwoo9643 — Thu, 1 Jan 2026 23:23:47 +0900

1. 개요 (Overview)

1.1 분석 배경

WannaCry는 2017년 전 세계적으로 대규모 피해를 입힌 랜섬웨어로, SMB 취약점(EternalBlue)을 통한 자가 전파 기능과 AES + RSA 혼합 암호 구조를 사용한다. 특히 Windows CryptoAPI 호출 시 생성된 대칭키가 메모리에 평문으로 남는 구조적 결함을 이용하면 복구가 가능하다.

1.2 핵심 요약

동적 모듈 로딩 : 리소스 내부에 암호화된 상태로 존재하는 DLL을 실행 시점에 메모리에서 복구하여 실제 암호화 로직을 구동한다.
하이브리드 암호화 : 파일별로 생성된 AES-128 키를 사용자용 RSA-2048 공개키로 보호하는 다층 구조를 채택하고 있다.
추출 데이터 기반 복구 : 키 생성 API 호출 시점을 가로채어 획득한 16바이트 대칭키 정보를 활용하면 공격자의 개인키 없이도 원본 데이터 복구가 가능하다.

2. 식별 정보 (Identification)

Malware Family: WannaCry (WanaCrypt0r 2.0)
Filetype: PE32 (Windows Executable)
Hash (SHA256): ed01ebfbc9eb5bbea545af4d01bf5f1071661840480439c6e5babe8e080e41aa
Extension: .WNCRY
Ransom Note: @Please_Read_Me@.txt
Encryption: AES-128-CBC + RSA-2048

3. 분석 환경 및 도구 (Tools)

구분	도구명 (Tool)	용도 (Purpose)
정적 분석	IDA Pro	바이너리 디스어셈블리 및 주요 암호화 서브루틴 분석
동적 분석	x64dbg	런타임 디버깅 및 메모리 내 키 데이터 추출
행위 분석	Process Monitor	파일 권한 변경 및 자가 복제 행위 추적
검증 도구	Python	후킹 데이터 기반 복호화 로직 구현 및 시그니처 검증

4. 암호화 기술 분석 (Technical Analysis)

4.1 초기화 및 설치

WannaCry는 실행 인자에 따라 동작 모드를 달리한다.

설치 모드 (i) : CopyFileA를 통해 자기 자신을 복제하고 시스템 서비스로 등록을 시도한다.
암호화 모드 (인자 없음) :
- 작업 디렉토리 설정(SetCurrentDirectoryA)
- 시스템 내 암호화 대상 파일 목록 수집
- 파일 권한을 변경하여 모든 사용자가 수정 가능하도록 조작(icacls)

4.2 암호화 DLL 로더

WannaCry의 실제 암호화 로직은 실행 파일 내부가 아닌, 리소스에 포함된 t.wnry 파일(암호화된 DLL 컨테이너)에 존재한다.

헤더 검증 : "WANACRY!" 매직 넘버 확인.
키 복구 : 내부 저장된 RSA 개인키로 AES 키를 복호화하여 t.wnry 내부의 DLL을 메모리 상에서 복구한다.
실행 : 복구된 DLL 내의 암호화 함수 포인터를 획득하여 호출한다.

4.3 키 생성 및 관리

WannaCry는 다층 구조의 키 관리 체계를 가진다.

사용자 RSA 키쌍 생성 : CryptGenKey를 통해 RSA-2048 키쌍(VPU/VPR)을 생성한다.
- 00000000.pky : 사용자 공개키 (Plaintext 저장)
- 00000000.eky : 사용자 개인키 (공격자의 마스터 공개키로 암호화되어 저장)
파일별 AES 키 생성 : 각 파일을 암호화할 때마다 CryptGenRandom(16)을 호출하여 고유한 AES-128 키를 생성한다.

4.4 파일 암호화 매커니즘

파일 암호화 시 다음과 같은 구조로 데이터를 재구성한다.

알고리즘 : AES-128-CBC (IV = 16바이트 Zero)
파일 구조:
- 0x00 : 매직 넘버 ("WANACRY!")
- 0x08 : RSA로 암호화된 AES 키 크기 (256바이트)
- 0x0C : RSA(VPU)로 암호화된 AES 세션 키
- 0x110 : 원본 파일 크기 (8바이트)
- 0x118 : AES-CBC로 암호화된 데이터

4.5 정적 분석

실행 파일 경로 획득 / 고유한 랜덤 서비스명 생성 (컴퓨터별)

인자 여부에 따른 실행 모드 분기
- “-i” 인자가 있을 때 : 설치/서비스 모드

설치 디렉터리 생성

디렉토리에 Hidden + System 속성 설정

tasksche.exe를 Windows 서비스로 등록하고 시작

조건 1: 인자 개수가 2개인가? (WannaCry.exe /i)
   ↓
조건 2: 두 번째 인자가 "/i"인가?
   ↓
조건 3: 설치 디렉토리 생성 성공?
        - 우선순위 1: C:\ProgramData\[랜덤이름]
        - 우선순위 2: C:\Intel\[랜덤이름]
        - 우선순위 3: %TEMP%\[랜덤이름]
        - 디렉토리에 Hidden + System 속성 설정
   ↓
조건 4: 현재 실행 파일을 tasksche.exe로 복사
   ↓
조건 5: tasksche.exe 파일이 정상적으로 생성되었는지 확인
   ↓
조건 6: tasksche.exe를 Windows 서비스로 등록하고 시작
        - 기존 서비스가 있으면 시작
        - 없으면 새로 생성하고 시작
        - 60초 동안 뮤텍스 생성 대기

모든 조건을 만족하면 → 설치 완료, 프로그램 종료
하나라도 실패하면 → 일반 실행 모드로 진행

“-i” 인자가 없을 때 : 일반 실행 모드

레지스트리에 경로 저장 (지속성 확보)

랜섬웨어 리소스 추출

비트코인 주소 설정

파일 숨김 및 권한 설정

시스템 호환성 확인

메인 페이로드 복호화 및 실행
- 암호화 DLL : t.wnry 파일에서 암호화된 DLL 추출 및 복호화
- 파일 검증 : "WANACRY!" 시그니처 확인
- RSA 복호화 : RSA 개인 키로 256바이트 암호화된 데이터 복호화 → AES 키 추출
- AES 복호화 : 추출한 AES-128 키로 페이로드 데이터 복호화 (AES-128-CBC)
- 메모리 반환 : 복호화된 페이로드가 담긴 메모리 주소 반환

AES-128-CBC 복호화

페이로드 진입점 탐색 (TaskStart 함수)

리소스 정리

1. 작업 디렉토리 설정
   ↓ strrchr로 파일 경로에서 마지막 '\' 찾기
   ↓ '\' 이후를 NULL로 변경 (디렉토리 경로만 추출)
   ↓ SetCurrentDirectoryA로 실행 파일의 디렉토리로 이동

2. 레지스트리에 경로 저장 (지속성 확보)
   ↓ registry_save_or_load_path(1) 호출
   ↓ HKLM\Software\WanaCrypt0r 또는 HKCU\Software\WanaCrypt0r에 현재 디렉토리 저장

3. 랜섬웨어 리소스 추출
   ↓ extract_zip_resources: 리소스 ID 0x80A (ZIP 파일) 추출
   ↓ 압축 해제하여 다음 파일들 생성:
      - @WanaDecryptor@.exe (랜섬노트 UI 프로그램)
      - 언어별 메시지 파일 (msg/m_*.wnry)
      - 기타 리소스 파일

4. 비트코인 주소 설정
   ↓ setup_bitcoin_address 호출
   ↓ 3개 비트코인 주소 중 랜덤으로 1개 선택:
      - 13AM4VW2dhxYgXeQepoHkHSQuy6NgaEb94
      - 12t9YDPgwueZ9NyMgw519p7AA8isjr6SMw
      - 115p7UMMngoj1pMvkpHijcRdfJNXj6LrLn
   ↓ __bitcoin_txt 파일에 선택한 주소 저장

5. 파일 숨김 및 권한 설정
   ↓ create_process_hidden("attrib +h .") - 현재 디렉토리 숨김 속성 설정
   ↓ create_process_hidden("icacls . /grant Everyone:F /T /C /Q")
      - 모든 사용자에게 전체 권한 부여
      - /T: 하위 디렉토리 포함
      - /C: 오류 무시하고 계속
      - /Q: 조용히 실행

6. 시스템 호환성 확인
   ↓ check_system_and_load_apis 호출
   ↓ Windows 버전 확인 (Vista 이상)
   ↓ 파일 작업 API 동적 로드:
      - CreateFileW, WriteFile, ReadFile
      - MoveFileW, MoveFileExW, DeleteFileW
      - CloseHandle

7. 메인 페이로드 복호화 및 실행
   ↓ init_resource_manager - 리소스 관리자 초기화
   ↓ prepare_resource_buffers - 리소스 버퍼 준비
   ↓ extract_and_decrypt_resource("t.wnry") - t.wnry 파일 복호화:
      │  ├ 파일 시그니처 확인: "WANACRY!"
      │  ├ RSA로 암호화된 AES 키 256바이트 읽기
      │  ├ RSA 개인키로 AES 키 복호화
      │  └ AES-128로 페이로드 복호화
   ↓ decompress_payload - 복호화된 페이로드 압축 해제
   ↓ get_payload_entry_point("TaskStart") - 페이로드에서 "TaskStart" 함수 찾기
   ↓ 페이로드 진입점 실행 → **메인 랜섬웨어 활동 시작**
      │  ├ 파일 암호화 시작
      │  ├ 랜섬노트 표시
      │  ├ 네트워크 공격 (SMB 취약점 악용)
      │  └ 시스템 복구 방지 (섀도우 복사본 삭제 등)
   ↓ cleanup_resource_manager - 리소스 정리

8. 프로그램 종료

5. 복호화 기술 분석 (Decryption Strategy)

5.1 동적 API 후킹을 통한 키 데이터 캡처

WannaCry는 탐지를 피하기 위해 암호화 API를 동적으로 로드한다. 이 호출 시점을 가로채어 복구에 필요한 핵심 인자들을 JSON 형태로 확보한다.

대칭키 원천 데이터 확보 : 암호화 모듈이 CryptGenRandom을 호출하여 생성하는 16바이트 난수를 캡처한다.
비대칭키 구조 재구성 : CryptExportKey 호출 시 노출되는 PRIVATEKEYBLOB을 가로채어 RSA 개인키의 구성 요소(modulus, prime1, prime2, exponent 등)를 복원한다.

5.2 암호화 컨테이너 및 헤더 분석

복호화를 위해 .WNCRY 파일의 구조를 정밀하게 파싱하여 암호화된 본문과 메타데이터를 분리한다.

헤더 식별 및 검증 : 파일 선두 8바이트의 매직 넘버(WANACRY!)를 통해 대상 파일 여부를 확인한다.
메타데이터 추출 :
- 키 블록 파싱 : RSA로 암호화된 AES 키의 크기(필드 0x08)를 읽어 데이터 오프셋을 계산한다.
- 원본 크기 복원 : 파일 종단에 추가된 패딩을 제거하기 위해 8바이트의 원본 크기(Original Size) 정보를 확보한다.

5.3 복호화 알고리즘 구현

캡처된 키 후보군을 순차적으로 대입하여 CBC 모드 복호화를 수행하는 핵심 로직이다.

def execute_aes_decryption(cipher_payload, key_candidate, original_size):
    """
    AES-128-CBC 알고리즘을 이용한 데이터 복구 로직
    """
    # IV(초기화 벡터)는 16바이트 Zero로 고정됨
    initial_vector = b'\x00' * 16
    
    # 1. 블록 크기(16바이트) 정렬을 위한 패딩 처리
    if len(cipher_payload) % 16 != 0:
        cipher_payload += b'\x00' * (16 - (len(cipher_payload) % 16))
    
    # 2. CBC 모드 복호화 엔진 초기화 및 실행
    cipher_engine = AES.new(key_candidate, AES.MODE_CBC, initial_vector)
    decrypted_raw = cipher_engine.decrypt(cipher_payload)
    
    # 3. 메타데이터에 기록된 원본 크기만큼 데이터 절삭 (패딩 제거)
    return decrypted_raw[:original_size]

5.4 다중 키 전수조사 및 무결성 검증

후킹된 JSON 로그에 여러 개의 키가 존재할 경우, 각 키로 복호화된 결과물의 상위 바이트(Magic Number)를 대조하여 최종 복구 성공 여부를 판별한다.

def verify_restored_content(data, ext):
    """
    복호화된 데이터의 파일 포맷 시그니처 검증
    """
    # 1. 파일 크기 임계값 검사
    if len(data) < 4: return False, "Invalid Length"

    # 2. 확장자별 매직 넘버 대조 (Whitelisting 방식)
    magic = data[:4]
    if ext in ['.JPG', '.JPEG'] and magic[:3] == b'\xFF\xD8\xFF':
        return True, "✅ JPEG 이미지 확인"
    elif ext == '.PNG' and magic == b'\x89PNG':
        return True, "✅ PNG 이미지 확인"
    elif ext == '.PDF' and magic[:4] == b'%PDF':
        return True, "✅ PDF 문서 확인"
    elif ext in ['.DOCX', '.XLSX'] and magic[:2] == b'PK':
        return True, "✅ MS Office (OpenXML) 확인"
    
    return False, "잘못된 복호화 시도"

6. 요약 및 결론 (Conclusion)

6.1 설계 의도 및 암호학적 한계

WannaCry는 설계 당시 공격자의 마스터 개인키(Master Private Key) 없이는 원본 데이터 복구가 불가능하도록 의도된 고강도 암호화 아키텍처를 보유하고 있다. 그러나 실제 구현 과정에서 파일 암호화에 직접적으로 관여하는 대칭키(AES-128) 생성 시점에 Windows CryptoAPI를 호출하며, 이 과정에서 키 데이터가 메모리 상에 평문(Plaintext)으로 노출되는 치명적인 설계 결함이 확인되었다.

6.2 데이터 복구 가능성 입증

본 분석을 통해 실시간 API 후킹으로 확보된 CryptGenRandom의 페이로드를 활용한 복구 메커니즘을 검증하였다. 이를 통해 공격자와의 타협이나 비용 지불 없이도 감염된 시스템 내부의 원본 파일을 안정적으로 복원할 수 있음을 입증하였으며, 이는 랜섬웨어 대응 전략에 있어 매우 중요한 기술적 근거가 된다.

7. 대응 및 예방 가이드 (Mitigation & Recovery)

7.1 초동 조치 및 데이터 보존 전략

프로세스 유지 및 메모리 보호 : 감염 식별 시 랜섬웨어 프로세스를 즉시 종료하거나 시스템을 재부팅하는 행위는 메모리에 상주하는 키 데이터를 소멸시키므로 지양해야 한다.
동적 데이터 추출 : 프로세스가 실행 중인 상태에서 메모리 덤프를 획득하거나 API 후킹 로그를 확보하여, 파일 복호화의 핵심인 CryptGenRandom 생성 키와 PRIVATEKEYBLOB 데이터를 선제적으로 추출해야 한다.
네트워크 격리 : 자가 전파를 차단하기 위해 즉시 네트워크를 차단하되, 시스템 전원은 유지하여 휘발성 증거(Volatile Evidence)를 보존하는 것이 복구의 핵심이다.

7.2 기술적 복구 프로세스

추출 키 기반 전수조사 : 확보된 AES 키 리스트를 복호화 엔진에 입력하여 .WNCRY 파일의 헤더 파싱 결과와 대조한다.
자동화 복구 수행 : 검증된 대칭키를 활용하여 decrypted 폴더 내에 원본 데이터를 재생성하며, 파일 시그니처 대조를 통해 복구 데이터의 무결성을 최종 확인한다.

부록: 침해 지표 (IOC)

구분	Type	Value
Hash	SHA256	ed01ebfbc9eb5bbea545af4d01bf5f1071661840480439c6e5babe8e080e41aa
File	Resource	t.wnry (Encrypted DLL Container)
Magic	String	WANACRY!
Extension	Suffix	.WNCRY