А можешь оформить пост тут /threads/29390/ ? чтобы не затерялось среди других сообщений.
Или если хочешь можешь отдельным топиком оформить /forums/145/
0x11229920, но первая инструкция (начало бранча) была в 0x11223344, и из адреса 0x11229920 мы прыгнули по адресу 0x55667788 (начало второго бранча) то наш хеш покрытия будет к примеру `0x11223344 ^ 0x55667788` - самый примитивный способ получения хеша угла. AFL++ -- заслуженный временем, кстати американский, но тщательно доработанный немецким напильником, фаззи луп =)снапшот бейзед, хардваре ковераж гайдед фаззинг. Самый модный, но абсолютно не рабочий из коробки.
/
* Fork server logic, invoked once we hit _start. */
// либо, там, где мы выставили переменной окружения, не обязательно в _start.
// \
вообще бородатые сеньйоры пожурили бы меня за комменты в два слеша, в файле сорцев, а не в файле хедеров, и убили бы за строчки длиннее 125 чаров, но я для простоты себе это позволю :3
void afl_forkserver(CPUState *cpu) {
// u32 map_size = 0;
unsigned char tmp[4] = {0};
if (forkserver_installed == 1) return;
forkserver_installed = 1;
if (getenv("AFL_QEMU_DEBUG_MAPS")) open_self_maps(cpu->env_ptr, 1);
pid_t child_pid;
int t_fd[2];
u8 child_stopped = 0;
u32 was_killed;
int status = 0;
// with the max ID value
if (MAP_SIZE <= FS_OPT_MAX_MAPSIZE)
status |= (FS_OPT_SET_MAPSIZE(MAP_SIZE) | FS_OPT_MAPSIZE);
if (lkm_snapshot) status |= FS_OPT_SNAPSHOT;
if (sharedmem_fuzzing != 0) status |= FS_OPT_SHDMEM_FUZZ;
if (status) status |= (FS_OPT_ENABLED | FS_OPT_NEWCMPLOG);
if (getenv("AFL_DEBUG"))
fprintf(stderr, "Debug: Sending status %08x\n", status);
memcpy(tmp, &status, 4);
/* Tell the parent that we're alive. If the parent doesn't want
to talk, assume that we're not running in forkserver mode. */
if (write(FORKSRV_FD + 1, tmp, 4) != 4) return;
afl_forksrv_pid = getpid();
int first_run = 1;
if (sharedmem_fuzzing) {
if (read(FORKSRV_FD, &was_killed, 4) != 4) exit(2);
if ((was_killed & (0xffffffff & (FS_OPT_ENABLED | FS_OPT_SHDMEM_FUZZ))) ==
(FS_OPT_ENABLED | FS_OPT_SHDMEM_FUZZ))
afl_map_shm_fuzz();
else {
fprintf(stderr,
"[AFL] ERROR: afl-fuzz is old and does not support"
" shmem input");
exit(1);
}
}
/* All right, let's await orders... */
while (1) { /* Тут вот начинается каждая итерация */
/* Whoops, parent dead? */
/* А дальше начинается что-то не очень понятное, но щас все разберем */
if (read(FORKSRV_FD, &was_killed, 4) != 4) exit(2); // ждем команду на запуск цикла
// по имени понятно какие логические значения команда может принимать
/* If we stopped the child in persistent mode, but there was a race
condition and afl-fuzz already issued SIGKILL, write off the old
process. */
// нас предупреждают, что тут возможно состояние гонки, причем между сигналов!
// имеется ввиду, что потомок уже отправил сам себе SIGSTOP, но пока мы возились AFL решил отправить потомку SIGKILL.
if (child_stopped && was_killed) { //тут мы обрабатываем этот кейс
child_stopped = 0; // это должно быть под ифкейсом, как по мне =)
if (waitpid(child_pid, &status, 0) < 0) exit(8); // "рипаем зомби".
}
if (!child_stopped) { /*
if (child_stopped == 0) { возможео минимум в двух случая:
либо мы его обнулили выше, либо это первая итерация.
для нас это всегда необходимость создавать нового потомка */
/* Establish a channel with child to grab translation commands. We'll
read from t_fd[0], child will write to TSL_FD. */
if (pipe(t_fd) || dup2(t_fd[1], TSL_FD) < 0) exit(3);
close(t_fd[1]);
child_pid = fork(); // форкаемся
if (child_pid < 0) exit(4);
if (!child_pid) { // предок
/* Child process. Close descriptors and run free. */
afl_fork_child = 1;
close(FORKSRV_FD);
close(FORKSRV_FD + 1);
close(t_fd[0]);
return;
}
/* Parent. */
close(TSL_FD);
} else { // если же мы в персисте и чайлд остановлен, то мы его продолжаем
/* Special handling for persistent mode: if the child is alive but
currently stopped, simply restart it with SIGCONT. */
kill(child_pid, SIGCONT);
child_stopped = 0;
}
/* Parent. */
// Тут нам нужно будет добавить сокеты и сетевой эмулятор...
if (write(FORKSRV_FD + 1, &child_pid, 4) != 4) exit(5);
// с обратной стороны канала оживает AFL, получив уведомление о запущеном потомке в виде PID потомка.
/* Collect translation requests until child dies and closes the pipe. */
// отголоски из прошлого. Когда потомок умирал после каждой итерации.
// у нас же (в стоке) из ожидания в чтении канала с кэшэм предка достают уловкой, покажу позже какой.
afl_wait_tsl(cpu, t_fd[0]);
/* Get and relay exit status to parent. */
// WUNTRACED также возвращаться, если есть остановленный потомок (но не трассируемый через ptrace(2)). Состояние трассируемого остановленного потомка предоставляется даже если этот аргумент не указан.
if (waitpid(child_pid, &status, is_persistent ? WUNTRACED : 0) < 0) exit(6);
/* In persistent mode, the child stops itself with SIGSTOP to indicate
a successful run. In this case, we want to wake it up without forking
again. */
// из waitpid() мы вернемся только когда потомок будет мертв (добровольно или по сигналу), либо остановится.
if (WIFSTOPPED(status))
child_stopped = 1;
else if (unlikely(first_run && is_persistent)) {
fprintf(stderr, "[AFL] ERROR: no persistent iteration executed\n");
exit(12); // Persistent is wrong
}
first_run = 0;
// информируем AFL как потомок завершил цикл
if (write(FORKSRV_FD + 1, &status, 4) != 4) exit(7);
}
}/* This is the other side of the same channel. Since timeouts are handled by
afl-fuzz simply killing the child, we can just wait until the pipe breaks. */
static void afl_wait_tsl(CPUState *cpu, int fd) {
struct afl_tsl t;
TranslationBlock *tb, *last_tb;
if (disable_caching) return;
while (1) {
u8 invalid_pc = 0;
/* Broken pipe means it's time to return to the fork server routine. */
if (read(fd, &t, sizeof(struct afl_tsl)) != sizeof(struct afl_tsl)) break;
/* Exit command for persistent */
// вот это важный момент, я нарочно поменял местами функции кеша родителя и потомка, что бы сперва показать этот минус один. \
это и есть тот трюк, которым родителя отрывают от ожидания кэша.
if (t.tb.pc == (target_ulong)(-1)) return;
tb = afl_tb_lookup(cpu, t.tb.pc, t.tb.cs_base, t.tb.flags, t.tb.cf_mask);
if (!tb) {
/* The child may request to transate a block of memory that is not
mapped in the parent (e.g. jitted code or dlopened code).
This causes a SIGSEV in gen_intermediate_code() and associated
subroutines. We simply avoid caching of such blocks.
Более того, зис куд симпли генерейт дифферентли чейнед блокс, ин фьючер,
мэйкинг АФЛ синк, зэт аур ковераж мап ис анстэйбл, мэйкинг ас сэд =)
решением в данном случае будет передача родителю системных вызовов mmap.
он просто (должен будет) мапит те же библиотеки в то же адресное пространство.
и потом уже транслирует код
*/
if (is_valid_addr(t.tb.pc)) {
// вот это ниже мьютекс, который тут не с проста. Пока что просто запомним, что он тут есть.
mmap_lock();
tb = tb_gen_code(cpu, t.tb.pc, t.tb.cs_base, t.tb.flags, t.tb.cf_mask);
mmap_unlock();
} else {
invalid_pc = 1;
}
}
if (t.is_chain && !invalid_pc) {
last_tb = afl_tb_lookup(cpu, t.chain.last_tb.pc,
t.chain.last_tb.cs_base,
t.chain.last_tb.flags,
t.chain.cf_mask);
#define TB_JMP_RESET_OFFSET_INVALID 0xffff
if (last_tb && (last_tb->jmp_reset_offset[t.chain.tb_exit] !=
TB_JMP_RESET_OFFSET_INVALID)) {
tb_add_jump(last_tb, t.chain.tb_exit, tb);
}
}
}
close(fd);
}/* This code is invoked whenever QEMU decides that it doesn't have a
translation of a particular block and needs to compute it, or when it
decides to chain two TBs together. When this happens, we tell the parent to
mirror the operation, so that the next fork() has a cached copy. */
static void afl_request_tsl(target_ulong pc, target_ulong cb, uint32_t flags,
uint32_t cf_mask, TranslationBlock *last_tb,
int tb_exit) {
if (disable_caching) return;
struct afl_tsl t;
if (!afl_fork_child) return;
t.tb.pc = pc;
t.tb.cs_base = cb;
t.tb.flags = flags;
t.tb.cf_mask = cf_mask;
t.is_chain = (last_tb != NULL);
if (t.is_chain) {
t.chain.last_tb.pc = last_tb->pc;
t.chain.last_tb.cs_base = last_tb->cs_base;
t.chain.last_tb.flags = last_tb->flags;
t.chain.cf_mask = cf_mask;
t.chain.tb_exit = tb_exit;
}
if (write(TSL_FD, &t, sizeof(struct afl_tsl)) != sizeof(struct afl_tsl))
return;
}/* A simplified persistent mode handler, used as explained in
* llvm_mode/README.md. */
static u32 cycle_cnt;
void afl_persistent_iter(CPUArchState *env) {
static struct afl_tsl exit_cmd_tsl;
// если не исчерпали кол-во итераций до перезапуска
if (!afl_persistent_cnt || --cycle_cnt) {
// если включена опция снапшотов памяти - восстанавливаем состояние страниц
if (persistent_memory) restore_memory_snapshot();
// если включен снапшот состояния регистров - восстанавливаем состояние регистров
// исключение - режим подгрузки либы персистент лупа.
// почитать про нее можешь и сам, иначе этот дред никогда не закончится
if (persistent_save_gpr && !afl_persistent_hook_ptr) {
afl_restore_regs(&saved_regs, env);
}
if (!disable_caching) {
memset(&exit_cmd_tsl, 0, sizeof(struct afl_tsl));
exit_cmd_tsl.tb.pc = (target_ulong)(-1); // маякуем предку что итерация подошла к концу
if (write(TSL_FD, &exit_cmd_tsl, sizeof(struct afl_tsl)) !=
sizeof(struct afl_tsl)) {
/* Exit the persistent loop on pipe error */
afl_area_ptr = dummy;
exit(0);
}
}
// TODO use only pipe
// Я с увжением отношусь к немцам написавшим AFL++
raise(SIGSTOP);
// now we have shared_buf updated and ready to use
if (persistent_save_gpr && afl_persistent_hook_ptr) {
struct api_regs hook_regs = saved_regs;
afl_persistent_hook_ptr(&hook_regs, guest_base, shared_buf,
*shared_buf_len);
afl_restore_regs(&hook_regs, env);
}
// боль
afl_area_ptr[0] = 1;
afl_prev_loc = 0;
} else {
// способ выключить покрытие на минималках
afl_area_ptr = dummy;
exit(0);
}
}
{ close(); }`void HELPER(afl_cmplog_rtn)(CPUArchState *env) {
#if defined(TARGET_X86_64)
target_ulong arg1 = env->regs[R_EDI];
target_ulong arg2 = env->regs[R_ESI];
#elif defined(TARGET_I386)
// AFL_G2H() конвертирует содержимое гостевога регистра, то бишь гостевой адрес памяти, в доменный.
target_ulong *stack = AFL_G2H(env->regs[R_ESP]);
if (!access_ok(env_cpu(env), VERIFY_READ, env->regs[R_ESP],
sizeof(target_ulong) * 2))
return;
// when this hook is executed, the retaddr is not on stack yet
target_ulong arg1 = stack[0];
target_ulong arg2 = stack[1];
// море-овер, вен зыс хук экхэкутед, другие потоки выполняются.
// и выше тоже. на любой архитектуре это будет не безопасно.
#else
// stupid code to make it compile
target_ulong arg1 = 0;
target_ulong arg2 = 0;
return;
#endif
if (!access_ok(env_cpu(env), VERIFY_READ, arg1, 0x20) ||
!access_ok(env_cpu(env), VERIFY_READ, arg2, 0x20))
return;
void *ptr1 = AFL_G2H(arg1);
void *ptr2 = AFL_G2H(arg2);
#if defined(TARGET_X86_64) || defined(TARGET_I386)
uintptr_t k = (uintptr_t)env->eip;
#else
uintptr_t k = 0;
#endif
k = (uintptr_t)(afl_hash_ip((uint64_t)k));
k &= (CMP_MAP_W - 1);
u32 hits = 0;
if (__afl_cmp_map->headers[k].type != CMP_TYPE_RTN) {
__afl_cmp_map->headers[k].type = CMP_TYPE_RTN;
__afl_cmp_map->headers[k].hits = 0;
__afl_cmp_map->headers[k].shape = 30;
} else {
hits = __afl_cmp_map->headers[k].hits;
}
__afl_cmp_map->headers[k].hits += 1;
hits &= CMP_MAP_RTN_H - 1;
((struct cmpfn_operands *)__afl_cmp_map->log[k])[hits].v0_len = 31;
((struct cmpfn_operands *)__afl_cmp_map->log[k])[hits].v1_len = 31;
// перфоманс для отцов =)
__builtin_memcpy(((struct cmpfn_operands *)__afl_cmp_map->log[k])[hits].v0,
ptr1, 31);
__builtin_memcpy(((struct cmpfn_operands *)__afl_cmp_map->log[k])[hits].v1,
ptr2, 31);
// тихие краши в cmplog вместо прохождения роад-блоков для деток
// мидлы юзают аналог copy_from_user() по ссылке ниже
}if (likely(!qatomic_mb_read(&cmplog_mode)) || !AFLGETCOV())
return;extern __thread bool aflThreadCov; // per_thread переменная. Аналог ядерной __per_cpu.
static inline void aflSetCovVal(bool x);
static inline bool aflAskCovVal(void);
static inline bool aflGetCovVal(void);
static inline void aflSwitchThrCov(bool cov);
// return true if global and thread coverage enabled
#define AFLGETCOV() aflGetCovVal()
// return true if global coverage is enabled
#define AFLASKCOV() aflAskCovVal()
// set @x to global coverage val
#define AFLSETCOV(x) aflSetCovVal((bool)(x))
// set current thread coverage flag
#define AFLSWITCH(x) aflSwitchThrCov(x)
// check @x (cmd from AFL) and return true if it is cmplog cycle
#define AFLGETCMP(x) ((((x) >> (sizeof(char) * 3 * 8)) & 0xFF) == 0xCC)
static inline void aflSetCovVal(bool x) {
qatomic_set(&aflTargetBusy, x);
}
// глобально (между Pre-Fuzz и Post-Fuzz)
static inline bool aflAskCovVal(void) {
return qatomic_mb_read(&aflTargetBusy);
}
static inline bool aflGetCovVal(void) {
// каст к булевому в треде либо включенна опция во всех тредах
return !!(aflAskCovVal() & (aflThreadCov | afl_all_thr_in_cov));
}
// атомарна т.к. доступается к ней только владелец.
static inline void aflSwitchThrCov(bool cov) { aflThreadCov = cov; }void HELPER(afl_maybe_log)(target_ulong curr, target_ulong next)
{
if (AFLGETCOV()) {
register uintptr_t afl_idx = aflHashIp( next, curr, afl_inst_rms );
// тут все атомарно, через интринсики (intrinsics)
INC_AFL_AREA(afl_idx);
// Интринсики завернуты во враперы qatomic_*()
// Они мне так понравились, что я их выпилил в отдельный заголовок и тягаю с собой в другие проекты
// aflPrevLoc - это адрес предыдущего блока. почему он хранится читай выше постом.
} aflPrevLoc = zeroCut(curr) >> 1;
}
/* Generates TCG code for AFL's tracing instrumentation. */
void afl_gen_trace(target_ulong curr, target_ulong next, bool isJmp) {
switch (afl_insr_policy) { // дуристика ...
case 1:
if ( isJmp || !(afl_must_instrument(curr) && afl_must_instrument(next)) )
return;
break;
default:
case 2:
if ( !afl_must_instrument(curr) )
return;
break;
case 3:
if ( !(afl_must_instrument(curr) || afl_must_instrument(next)) )
return;
break;
}
TCGv curr_v = tcg_const_tl(curr);
TCGv next_v = tcg_const_tl(next);
tcg_gen_mb(TCG_MO_ALL | TCG_BAR_SC); // даже бл*ть в TCG нашел примитивы синхронищации, это п*здец
gen_helper_afl_maybe_log(curr_v, next_v);
tcg_gen_mb(TCG_MO_ALL | TCG_BAR_SC);
tcg_temp_free(next_v);
tcg_temp_free(curr_v);
}
// движек генератора JIT кода. Промежуточное представление между машинным кодом гостя и домена.
/* Called with mmap_lock held for user mode emulation. */
TranslationBlock *tb_gen_code(CPUState *cpu,
target_ulong pc, target_ulong cs_base,
uint32_t flags, int cflags)
{
CPUArchState *env = cpu->env_ptr;
TranslationBlock *tb, *existing_tb;
tb_page_addr_t phys_pc;
tcg_insn_unit *gen_code_buf;
int gen_code_size, search_size, max_insns;
#ifdef CONFIG_PROFILER
TCGProfile *prof = &tcg_ctx->prof;
int64_t ti;
#endif
void *host_pc;
assert_memory_lock();
qemu_thread_jit_write();
... snipped ...
tcg_func_start(tcg_ctx);
tcg_ctx->cpu = env_cpu(env); // указатель на местную task_struct используется для получения указателя на __cpu
curr_tb->good = 1; // вместо cur_block_is_good. Предварительно был добавлен в структуру struct TranslationBlock, выдержка ниже
tb->exec_cnt = 0; // так же. используется для трассировщика
tb->red = AFLASKCOV(); // для трассировщика. Смысл: если блок переводится когда тред + цикл в "рабочем окне" - блок красный (горячий) и на него хорошо ставить пре/пост точки.
tb->determinated = aflThreadId; // для трассировщика. Смысл: если блок выполняется одним и тем же TID - детерменирован.
// хелпер трассера
afl_gen_btrace(tb);
// мудак
afl_gen_trace(tb->pc, 0x12345, 0);
gen_intermediate_code(cpu, tb, max_insns, pc, host_pc);
afl_gen_fncov(pc);
assert(tb->size != 0);
tcg_ctx->cpu = NULL;
max_insns = tb->icount;
// родной трассировщик...)
trace_translate_block(tb, tb->pc, tb->tc.ptr);
...snipped...
}struct TranslationBlock {
target_ulong pc; /* simulated PC corresponding to this block (EIP + CS base) */
target_ulong cs_base; /* CS base for this block */
uint32_t flags; /* flags defining in which context the code was generated */
uint32_t cflags; /* compile flags */
... snipped ...
/*
* Each TB has a NULL-terminated list (jmp_list_head) of incoming jumps.
* Each TB can have two outgoing jumps, and therefore can participate
* in two lists. The list entries are kept in jmp_list_next[2]. The least
* significant bit (LSB) of the pointers in these lists is used to encode
* which of the two list entries is to be used in the pointed TB.
*
* List traversals are protected by jmp_lock. The destination TB of each
* outgoing jump is kept in jmp_dest[] so that the appropriate jmp_lock
* can be acquired from any origin TB.
*
* jmp_dest[] are tagged pointers as well. The LSB is set when the TB is
* being invalidated, so that no further outgoing jumps from it can be set.
*
* jmp_lock also protects the CF_INVALID cflag; a jump must not be chained
* to a destination TB that has CF_INVALID set.
*/
uintptr_t jmp_list_head;
uintptr_t jmp_list_next[2];
uintptr_t jmp_dest[2];
uint64_t exec_cnt;
uint8_t red;
uint8_t determinated;
uint8_t good; /* will be true if aflMustInstrument(tb->pc) return true */
};static void afl_gen_btrace(void *tb_ptr) {
// трассер включен? Если нет все что ниже не выполняется
if (likely(!afl_trace_exec_blocks))
return;
// что такое TCGv_ptr, почему оно используется - в инете есть. С удовольствием послушаю в твоем исполнении)
TCGv_ptr tb_v = tcg_const_ptr(tb_ptr);
gen_helper_afl_maybe_trace(tb_v); // если да в начале каждого блока будет сгенерирован вот тот кодес, что ниже
tcg_temp_free_ptr(tb_v);
}
void HELPER(afl_maybe_trace)(void * ptr)
{
afl_trace_executed((TranslationBlock *)ptr);
}
static inline void afl_trace_executed(TranslationBlock *current_tb) {
qatomic_inc(¤t_tb->exec_cnt);
if (current_tb->red) // ну такое
qatomic_set(¤t_tb->red, AFLASKCOV());
// начитавшить Линуса Торвальда
u8 determ = qatomic_cmpxchg(¤t_tb->determinated, (u8)aflThreadId, (u8)aflThreadId);
if (determ && determ != aflThreadId) {
qatomic_mb_set(¤t_tb->determinated, 0);
QDEBUGF(cYEL "[INFO]: marking new tb as non-deterministic one [ %#.16lx ] \n", (long)current_tb->pc);
}
// afl_tb_exe_cnt_lim и afl_trace_current_num: вот это отличная опция. Как работает покажу ниже
if (( current_tb->good || afl_trace_cov_full )
&& ( afl_tb_exe_cnt_lim ? (ulong)afl_tb_exe_cnt_lim > current_tb->exec_cnt : !!1 )
&& ( afl_trace_cov_only ? AFLASKCOV() : 1 )
&& ( afl_trace_current_num == qatomic_mb_read(¤t_tb->exec_cnt) )) {
QDEBUGF("[ EXE ] [ %#.16lx ] { %sDET"cRST"|%sRED"cRST" } (B=%ld, T=%ld, I=%ld C=%.8lu)\n",
(long)current_tb->pc, current_tb->determinated ? cGRN : cRED, (bool)current_tb->red ? cRED : cGRA,
(long)aflTargetBusy, (long)aflThreadCov, (long)aflThreadId,
(ulong)current_tb->exec_cnt);
}
}
грусно видеть. столько труда и ноль эмоций. а татушки\шлюшки Лохбитов собирают аншлаг.
вероятно на лохбита лохи велись, а тут такой крутой проект что мало кто поймет вообще для чего он нужен