Skip to content
KitploitKITPLOIT
도구익스플로잇블로그
Log in
제출
도구익스플로잇블로그
제출

해킹, 침투 테스트 및 사이버 보안 도구를 당신의 보안 무기고에!

Kitploit은 해킹, 사이버 보안 및 침투 테스트 도구 디렉토리입니다. 최신 프로젝트 업데이트를 발견하여 취약점을 찾고, 시스템을 분석하고, 테스트를 자동화하고, 보안을 강화하세요.

피드문의개인정보© 2026 Kitploit

도구 디렉토리

카테고리

모든 카테고리 보기
Loading categories
static_asm — x86/x86-64 명령어 인코딩을 위한 헤더 전용 C++2x 컴파일 타임 어셈블러 | Kitploit
도구/GitHubGitHub/mahmoudimus/static_asm
Payload GenerationCode AnalysisExploitationReverse EngineeringShellcodeBinary AnalysisLearning & EducationShellcode GenerationLearning Paths & Courses
GitHubmahmoudimus/static_asm

static_asm

x86/x86-64 명령어 인코딩을 위한 헤더 전용 C++2x 컴파일 타임 어셈블러

311461개월 전Kitploit 검토 완료
공유
저장소 보기웹사이트

static_asm

CI License

컴파일 타임 x86/x86-64 명령어 인코딩을 위한 헤더 온리 C++20 라이브러리입니다.

이 프로젝트는 Boost Software License 1.0과 MIT License에 따라 이중 라이선스가 적용됩니다. 둘 중 하나를 선택할 수 있습니다.

목적

  • 실용적이고 재미있는 방식으로 x86 어셈블리 인코딩 배우기
  • 완전한 타입 안전성을 갖춘 컴파일 타임 어셈블리 명령어 생성
  • 런타임 오버헤드 없이 셸코드 및 JIT 코드 템플릿 생성

빠른 시작

#include "static_asm.hpp"

using namespace static_asm;
using namespace static_asm::x86;
using namespace static_asm::x86::registers;
using namespace static_asm::x86::instructions;

// Build machine code at compile time
constexpr auto code = core::assemble(
    mov(rax, 0x12345678),    // mov rax, imm32
    add(rax, rcx),           // add rax, rcx
    xor_(r8, r8),            // xor r8, r8
    call(rax),               // call rax
    ret()                    // ret
);
// code is std::array<uint8_t, N> - fully constexpr!

명명된 분기와 임베디드 데이터에 대해서는 레이블 및 분기 완화를 참조하십시오.

카테고리별 예제

ALU 연산

// Register to register
add(rax, rbx);           // 48 01 D8
sub(ecx, edx);           // 29 D1
and_(r8, r9);            // 4D 21 C8
or_(rsi, rdi);           // 48 09 FE
xor_(eax, eax);          // 31 C0 (common idiom to zero a register)
cmp(rax, rcx);           // 48 39 C8

// Register with immediate
add(rax, 0x10);          // 48 83 C0 10 (sign-extended imm8)
add(rax, 0x10000);       // 48 05 00 00 01 00 (imm32)
sub(ecx, 100);           // 83 E9 64
and_(rdx, 0xFF);         // 48 83 E2 FF

// With memory operands
add(eax, dword_ptr(rbx));                        // 03 03
add(rax, qword_ptr(rcx + disp<0x10>));           // 48 03 41 10
sub(dword_ptr(rsp + disp<0x20>), eax);           // 29 44 24 20

가장 짧은 변위에는 disp<value>를 사용하십시오. 이는 0에 대해 합법적인 경우 변위를 선택하지 않고, -128부터 127까지는 부호 있는 disp8을, 그 외에는 disp32를 선택합니다. RIP 상대 주소는 항상 disp32가 필요하며, 0인 RBP/R13도 여전히 0 disp8이 필요합니다. 부호 있는 32비트 범위를 벗어나는 값은 컴파일 실패합니다. rcx + 0x10과 같은 일반 정수는 여전히 disp32를 사용합니다. C++는 int 인자의 값에 따라 서로 다른 정확한 크기의 명령어 배열 타입을 선택할 수 없기 때문입니다. 일반 베이스를 사용하는 [base + disp]는 정규 ModR/M 전용 형식(SIB 바이트 없음)을 사용하며, RSP/R12 베이스는 하드웨어가 요구하기 때문에 SIB 바이트를 생성합니다.

데이터 이동

// Register to register
mov(rax, rbx);           // 48 89 D8
mov(eax, ecx);           // 89 C8
mov(r8, r9);             // 4D 89 C8

// Immediate to register
mov(rax, 0x12345678);    // 48 C7 C0 78 56 34 12
mov(eax, 0xDEADBEEF);    // B8 EF BE AD DE

// Memory operations
mov(rax, qword_ptr(rbx));                        // 48 8B 03
mov(eax, dword_ptr(rcx + disp<0x10>));           // 8B 41 10
mov(rax, qword_ptr(rbp - disp<0x20>));           // 48 8B 45 E0 (canonical, no SIB)
mov(qword_ptr(rsp + disp<0x8>), rax);            // 48 89 44 24 08 (RSP base needs SIB)

// Zero/sign extension
movzx(eax, bl);          // 0F B6 C3 (zero-extend byte to dword)
movzx(rax, bx);          // 48 0F B7 C3 (zero-extend word to qword)
movsx(eax, cl);          // 0F BE C1 (sign-extend byte to dword)
movsx(rax, dx);          // 48 0F BF C2 (sign-extend word to qword)
movsxd(rax, ecx);        // 48 63 C1 (sign-extend dword to qword)

// Load effective address
lea(rax, qword_ptr(rbx + rcx * s4));                      // 48 8D 04 8B
lea(rax, qword_ptr(rbx + rcx * s8 + disp<0x10>));         // 48 8D 44 CB 10

// Exchange (register or memory; XCHG is symmetric)
xchg(rax, rbx);                                  // 48 87 D8
xchg(qword_ptr(rcx), rax);                       // 48 87 01
xchg(rbx, qword_ptr(rcx + disp<0x10>));          // 48 87 59 10

// Store an immediate to a displaced / SIB / RIP memory destination
mov(dword_ptr(rbp - disp<0x20>), 0x100);         // C7 45 E0 00 01 00 00
mov(qword_ptr(rcx + disp<0x10>), 1);             // 48 C7 41 10 01 00 00 00
add(qword_ptr(rbx + disp<0x8>), 0x10);           // 48 81 43 08 10 00 00 00

qword 메모리 목적지는 부호 확장된 32비트 즉시값 인코딩만을 가집니다. 정수의 64비트 비트 패턴은 해당 인코딩과 일치해야 합니다. 예를 들어 0x7FFFFFFF와 -0x80000000LL은 적합하지만, 양수 0x80000000ULL은 적합하지 않습니다. 유효하지 않은 값은 상수 평가에 실패하거나 런타임에 std::out_of_range를 발생시킵니다. 예외가 비활성화된 경우, 유효하지 않은 런타임 값은 프로그램을 종료시킵니다. 명시적인 imm32 피연산자는 원시 4바이트 즉시값을 제공합니다.

RIP 상대 주소 지정

rip + disp(및 rip - disp)는 64비트 RIP 상대 형식(ModR/M mod=00 r/m=101, 필수 disp32, 절대 SIB 바이트 없음)을 인코딩합니다:

mov(rax, qword_ptr(rip + 0x10));   // 48 8B 05 10 00 00 00
lea(rax, qword_ptr(rip + 0x100));  // 48 8D 05 00 01 00 00
add(qword_ptr(rip + 0x20), rbx);   // 48 01 1D 20 00 00 00
inc(qword_ptr(rip + 0x40));        // 48 FF 05 40 00 00 00
test(rax, qword_ptr(rip + 0x10)); // 48 85 05 10 00 00 00
test(qword_ptr(rip + 0), 0x10);   // 48 F7 05 00 00 00 00 10 00 00 00

SIB 주소 지정 (Scale-Index-Base)

// [base + index*scale]
mov(eax, dword_ptr(rbx + rcx * s1));   // 8B 04 0B
mov(eax, dword_ptr(rbx + rcx * s2));   // 8B 04 4B
mov(eax, dword_ptr(rbx + rcx * s4));   // 8B 04 8B
mov(eax, dword_ptr(rbx + rcx * s8));   // 8B 04 CB

// [base + index*scale + displacement]
mov(rax, qword_ptr(rbx + rcx * s4 + disp<0x10>));         // 48 8B 44 8B 10
mov(rax, qword_ptr(r12 + r13 * s8 + 0x1000));             // 4B 8B 84 EC 00 10 00 00

// Store to SIB address
mov(dword_ptr(rax + rdx * s4), ecx);                      // 89 0C 90
mov(qword_ptr(rbx + rsi * s8 + disp<0x20>), rax);         // 48 89 44 F3 20

// LEA with SIB (useful for address calculations)
lea(rax, qword_ptr(rbx + rcx * s4));                      // 48 8D 04 8B
lea(rax, qword_ptr(rdi + rsi * s8 + 0x100));              // 48 8D 84 F7 00 01 00 00

시프트 및 회전

// Shift by 1
shl(eax, 1);             // D1 E0
shr(rax, 1);             // 48 D1 E8
sar(ecx, 1);             // D1 F9

// Shift by immediate
shl(eax, 4);             // C1 E0 04
shr(rax, 8);             // 48 C1 E8 08
sar(rdx, 16);            // 48 C1 FA 10

// Shift by CL register
shl(eax, cl);            // D3 E0
shr(rax, cl);            // 48 D3 E8

// Rotate
rol(eax, 1);             // D1 C0
ror(rax, 8);             // 48 C1 C8 08
rcl(ecx, cl);            // D3 D1
rcr(rdx, 1);             // 48 D1 DA

곱셈과 나눗셈

// Single operand (result in rdx:rax)
mul(rbx);                // 48 F7 E3 (unsigned: rdx:rax = rax * rbx)
imul(rcx);               // 48 F7 E9 (signed: rdx:rax = rax * rcx)
div(rbx);                // 48 F7 F3 (unsigned: rax = rdx:rax / rbx, rdx = remainder)
idiv(rcx);               // 48 F7 F9 (signed division)

// Two-operand IMUL (dest = dest * src)
imul(rax, rbx);          // 48 0F AF C3
imul(ecx, edx);          // 0F AF CA

// Three-operand IMUL (dest = src * imm)
imul(rax, rbx, 10);      // 48 6B C3 0A
imul(ecx, edx, 1000);    // 69 CA E8 03 00 00

// Single-operand form with a memory operand
mul(qword_ptr(rcx));                             // 48 F7 21
imul(qword_ptr(rcx + disp<0x20>));               // 48 F7 69 20
div(dword_ptr(rax + disp<0x10>));                // F7 70 10
idiv(qword_ptr(rbx));                            // 48 F7 3B

증가 / 감소 / 부정 / 논리 부정

// Register operands
inc(rax);                // 48 FF C0
dec(ecx);                // FF C9
neg(rbx);                // 48 F7 DB
not_(rdx);               // 48 F7 D2

// Memory operands (canonical ModR/M-only addressing)
inc(qword_ptr(rcx));                             // 48 FF 01
inc(qword_ptr(rcx + disp<0x20>));                // 48 FF 41 20
dec(dword_ptr(rax + disp<0x10>));                // FF 48 10
neg(qword_ptr(rbx));                             // 48 F7 1B
not_(qword_ptr(rbx - disp<0x4>));                // 48 F7 53 FC

LOCK 접두사

lock_는 인코딩된 모든 명령어 앞에 LOCK 접두사(0xF0)를 붙여 메모리에 대한 읽기-수정-쓰기를 원자적으로 만듭니다:

lock_(inc(qword_ptr(rcx + disp<0x20>)));         // F0 48 FF 41 20
lock_(add(dword_ptr(rax), ecx));                 // F0 01 08

바이트 수준의 얇은 래퍼이며, 래핑된 명령어가 CPU에서 LOCK을 허용하는 명령어인지 검증하지 않습니다.

제어 흐름

도구 다운로드

인기

모두 보기 →

커뮤니티에서 가장 많이 사용되는 도구를 찾아보세요.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 궁극의 OSINT 툴킷: 조사 그래프, 신뢰도 점수 산정, 별칭 패밀리, 지도, 타임라인 및 보고서. 49개 모듈, 400개 이상 사이트, API 키 불필요.

    668
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # GhostLock 원탭 실행 앱 (CVE-2026-43499)

    496
  • 3

    ARTEX

    baarai/artex

    LLM 멀티 에이전트 자율 침투 테스트 플랫폼으로, 플래너/워커 에이전트, 자산 및 탐색 그래프, MITM 트래픽 기록, 취약점 재테스트 기능을 제공합니다.

    394
  • 4

    redforge

    cybersecurity91/redforge

    브라우저 측 레드 팀 툴킷으로, 정찰, 페이로드 생성, 자격 증명 공격, 암호화, 인코딩 및 참여 보고를 위한 102개의 오프라인 도구를 제공합니다.

    339
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    AI 네이티브 사이버보안을 위한 행동 체계—의도가 통제된 실행이 되고, 증거가 운영 메모리가 되며, 모든 운영이 다음 운영을 개선하는 곳.

    258
  • 6

    antifox

    antifox-ai/antifox

    정찰, 공격 표면 탐색, 익스플로잇 검증, 증거 기반 보고서 전달을 수행하는 AI 멀티 에이전트 자율 침투 테스트 플랫폼입니다.

    254

모든 도구 탐색

도구 컬렉션을 둘러보세요

모든 도구 보기 →