How Trail of Bits helps verify the integrity of your Signal chats

https://blog.trailofbits.com/2026/08/11/how-trail-of-bits-helps-verify-the-integrity-of-your-signal-chats

@reverseengine

LLM Poisoning [1/3] - Reading the thoughts of a Transformer

https://www.synacktiv.com/publications/llm-poisoning-13-lire-les-pensees-dun-transformer

@reverseengine

From P-Code to GNN: extract binary code semantics

https://blog.quarkslab.com/from-p-code-to-gnn-extract-binary-code-semantics.html

@reverseengine

Instruction Substitution

وقتی یک دستور رو با چند دستور دیگه عوض میکنیم

تا اینجا درباره روش‌های مختلفی صحبت کردیم که یک باینری میتونه طوری ساخته بشه که تحلیلش سخت‌ تر بشه
حالا بریم سراغ یکی از تکنیک‌های ساده ولی خیلی کاربردی:

Instruction Substitution

ایده‌اش خیلی ساده‌ ست:
به‌جای اینکه از یک دستور مشخص استفاده کنیم کاری میکنیم که چند دستور دیگه دقیقا همون نتیجه رو تولید کنه

یعنی مثلا اگر یک عملیات رو بتونیم با یک دستور انجام بدیم عمدا اون رو با چند دستور جایگزین میکنیم

یک مثال ساده:

فرض کنیم در Assembly میخایم یک رجیستر رو صفر کنیم

روش معمول:

xor eax, eax

بعد از اجرا:

EAX = 0

اما میتونیم همین نتیجه رو به شکل دیگه ای ایجاد کنیم:

sub eax, eax

باز هم:

EAX = 0

از نظر نتیجه نهایی هر دو یکی ان
ولی از نظر شکل کد متفاوتن

یک مثال دیگه

فرض کنیم:

mov eax, 0

می‌تونه با روش‌های دیگه ای هم به صفر برسه:

xor eax, eax

یا:

sub eax, eax

پس یک منطق واحد میتونه چندین representation مختلف داشته باشه
این دقیقا همون چیزیه که Instruction Substitution روی اون حساب میکنه

چرا این کار مهمه؟
اینجا یک نکته مهم وجود داره
اگر یک Analyst یا ابزار تحلیل انتظار داشته باشیم یک عملیات رو با شکل خاصی ببینیم Instruction Substitution میتونه اون الگو رو تغییر بده
مثلا تحلیلگر ممکنه که در یک باینری دنبال:

xor eax, eax

بگرده

اما سازنده باینری به‌ جای اون نوشته:

sub eax, eax

نتیجه یکیه ولی pattern عوض شده

یک مثال کمی جالب‌تر

فرض کنیم می‌خواهیم:

add eax, 1

رو انجام بدیم

میتونیم از:

inc eax

استفاده کنیم

هر دو مقدار EAX رو یک واحد افزایش میدن
یعنی:

قبل:

EAX = 10

بعد:

EAX = 11

اما Assembly متفاوته

حالا یک نکته مهم‌ تر:

Instruction Substitution
فقط برای یک دستور ساده نیست

بعضی وقتا یک عملیات رو میتونیم با چند دستور پیاده کنیم

مثلا:

add eax, 5

میتونیم به شکل دیگه ای بنویسیمش:

push 5
pop ecx
add eax, ecx

از نظر نتیجه میتونن معادل باشن هر چند این مثال عمدا ساده و ناکار آمده
هدف اینجا سرعت نیست
هدف اینه که:

یک عملیات چند representation متفاوت داشته باشیم

چرا مهمه؟
چون نباید فقط به شکل دستور نگاه کنه

باید بپرسید:

این چند دستور در اخر چه کاری انجام میدن

مثلا اگر ببینیم:

xor eax, eax

خیلی سریع میگیم:

EAX = 0

اما اگر ببینیم:

sub eax, eax

باز هم باید همون مفهوم رو تشخیص بدیم

پس در Reverse Engineering باید کم‌ کم از:
Instruction Thinking
به:
Semantic Thinking
حرکت کنیم

یعنی به‌جای اینکه فقط بگیم:

این دستور چیه؟

بپرسیم:

نتیجه منطقی این قسمت از برنامه چیه؟

این موضوع در Decompiler هم مهمه

Decompiler
ها تلاش میکنن Assembly رو دوباره به چیزی شبیه کد سطح بالا تبدیل کنن

مثلا:

xor eax, eax

ممکنه به چیزی شبیه:

eax = 0

تبدیل بشه

اگر همین کار با چند دستور مختلف انجام شده باشه Decompiler باید بفهمه که این مجموعه در اخر چه معنایی دارن

پس:

Assembly
↓
Instructions
↓
Semantic Analysis
↓
High-Level Representation

یکی از بخش‌های مهم Reverse Engineering همین تشخیص semantic هست

اما یک نکته خیلی مهم

Instruction Substitution
همیشه کاملا معادل نیست
ممکنه دو دستور از نظر مقدار نهایی یکسان باشن ولی روی:

Flags
Registers
Memory
Exception behavior
Timing

تاثیر متفاوتی داشته باشن

مثلا:

inc eax

و:

add eax, 1

از نظر مقدار EAX شبیهن اما رفتار Flag هاشون دقیقا یکی نیست

پس وقتی میگیم:

دو instruction equivalent هستند

باید مشخص کنیم:

از چه نظر؟

فقط نتیجه رجیستر؟

یا تمام State پردازنده؟

این تفاوت در Reverse Engineering خیلی مهمه

Instruction Substitution
در Obfuscation

حالا برگردیم به بحث اصلی
فرض کنیم یک برنامه این عملیات رو انجام میده:

xor eax, eax

در حالت عادی خیلی راحت قابل تشخیصه
اما اگر سازنده برنامه از روش‌ های مختلف برای تولید همون نتیجه استفاده کنه الگوی Assembly تغییر میکنه

مثلا:

sub eax, eax

یا در شرایط مناسب ترکیب‌ های پیچیده‌ تر
حالا اگر همین کار در قسمت‌های مختلف برنامه با شکل‌ های مختلف تکرار بشه تحلیل pattern-based سخت‌ تر میشه

مثلا:

Operation A
↓
Representation 1

Operation A
↓
Representation 2

Operation A
↓
Representation 3

در حالی که:

Semantic = یکی هست

@reverseengine

Instruction Substitution

When we replace an instruction with several other instructions

So far we have talked about different ways that a binary can be made to be more difficult to analyze

Now let's move on to one of the simple but very useful techniques:

Instruction Substitution

The idea is very simple:

Instead of using a specific instruction, we make several other instructions produce exactly the same result

That is, for example, if we can perform an operation with one instruction, we deliberately replace it with several instructions

A simple example:

Suppose we want to zero a register in Assembly

The usual method:

xor eax, eax

After execution:

EAX = 0

But we can create the same result in another way:

sub eax, eax

Again:

EAX = 0

In terms of the final result, both are the same

But in terms of the code format, they are different

Another example

Suppose:

mov eax, 0

Can also be zeroed in other ways:

xor eax, eax

or:

sub eax, eax

So a single logic can have multiple different representations

This is exactly what Instruction Substitution is counting on

Why is this important?

Here is an important point
If an Analyst or Analysis Tool expects to see an operation in a specific form, Instruction Substitution can change that pattern
For example, the Analyst might look for:

xor eax, eax

in a binary

but the Binary Builder instead writes:

sub eax, eax

The result is the same but the pattern has changed

A slightly more interesting example

Suppose we want to:

add eax, 1

We can use:

inc eax

Both increase the value of EAX by one

That is:

Before:

EAX = 10

After:

EAX = 11

But Assembly is different

Now a more important point:

Instruction Substitution

is not just for a simple instruction

Sometimes we can implement an operation with multiple instructions

For example:

add eax, 5

We can do it in a different way Let's write it:

push 5
pop ecx
add eax, ecx

They can be equivalent in terms of the result, although this example is intentionally simple and ineffective.

The goal here is not speed.

The goal is to:

Have several different representations of an operation.

Why is it important?

Because you shouldn't just look at the form of the instruction.

You should ask:

What do these instructions do in the end?

For example, if we see:

xor eax, eax

we say very quickly:

EAX = 0

But if we see:

sub eax, eax

we still have to recognize the same concept.

So in Reverse Engineering, we should gradually move from:

Instruction Thinking

to:

Semantic Thinking

That is, instead of just saying:

What is this instruction?

we should ask:

What is the logical result of this part of the program?

This is also important in Decompiler

Decompilers try to convert Assembly back to something like high-level code

For example:

xor eax, eax

may be converted to something like:

eax = 0

If the same thing is done with several different instructions, the Decompiler needs to understand what this set means in the end

So:

Assembly
↓
Instructions
↓
Semantic Analysis
↓

High-Level Representation
One of the important parts of Reverse Engineering is this semantic recognition

But one very important point

Instruction Substitution
is not always completely equivalent
Two instructions may be the same in terms of final value but have different effects on:

Flags
Registers
Memory
Exception behavior
Timing

For example:

inc eax

and:

add eax, 1

are similar in terms of EAX value but their Flag behavior is not exactly the same

So when we say:

two instructions are equivalent Are

We need to specify:

In what sense?

Only the result of the register?

Or the entire processor state?

This difference is very important in Reverse Engineering

Instruction Substitution
In Obfuscation

Now let's return to the main discussion
Suppose a program performs this operation:

xor eax, eax

In the normal case, it is very easy to recognize
But if the program creator uses different methods to produce the same result, the Assembly pattern changes

For example:

sub eax, eax

Or in appropriate conditions, more complex combinations
Now, if the same thing is repeated in different parts of the program with different forms, pattern-based analysis becomes more difficult

For example:

Operation A
↓
Representation 1

Operation A
↓
Representation 2

Operation A
↓

Representation 3
While:

Semantic = is one

@reverseengine

نکته طلایی

وقتی با کد Obfuscated مواجه شدید دنبال شکل ظاهری instruction ها نباشید
دنبال اثر اونها روی Machine State باشید

یعنی بررسی کنید:

Registerها چی شدن؟
Memory چه تغییری کردن؟
Flagها چی شدن؟
Control Flow کجا رفت؟

اگر این‌ها رو بفهمید حتی اگر شکل Assembly کاملا عجیب باشه میتونید منطق واقعی برنامه رو استخراج کنید

یک تمرین خیلی خوب

این چهار قطعه رو ببینید:

xor eax, eax

sub eax, eax

mov eax, 0

push 0

pop eax

همه رو فقط از یک زاویه نگاه نکنید

برای هر کدوم بررسی کنید:

EAX چی میشه؟
Flags چی میشن؟
Stack چه تغییری میکنه؟
Memory چه تغییری میکنه؟




Instruction Substitution:

یک عملیات رو با instruction یا instruction های دیگه ای پیاده سازی کنیم بدون اینکه semantic مورد نظر تغییر کنه

هدف میتونه:

تغییر شکل کد
سخت‌تر کردن Pattern Matching

افزایش تنوع instruction ها
Obfuscation
سخت‌تر کردن Static Analysis
باشده

اما برای ما یک درس خیلی مهم داره:

Assembly
رو نباید فقط بر اساس اسم instruction ها تحلیل کنیم باید semantic و اثر واقعی اونها رو روی CPU بفهمیم

و این دقیقا ساختار ماست:

Assembly Basics
        ↓
Disassembly
        ↓
Instruction Semantics
        ↓
Obfuscation
        ↓
Deobfuscation

@reverseengine

Golden Tip

When you encounter Obfuscated code, don't look for the appearance of the instructions
Look for their effect on the Machine State

That is, check:

What happened to the Registers?

What changed in Memory?

What happened to the Flags?

Where did the Control Flow go?

If you understand these, even if the Assembly form is completely strange, you can extract the real logic of the program

A very good exercise

Look at these four pieces:

xor eax, eax

sub eax, eax

mov eax, 0

push 0

pop eax

Don't look at everything from just one angle

For each, check:

What happens to EAX?

What happens to Flags?

What changes to the Stack?

What changes to Memory?

Instruction Substitution:

Implement an operation with another instruction or instructions without changing the intended semantics

The goal can be:

Change the shape of the code

Make Pattern Matching harder

Increase the variety of instructions

Obfuscation

Make Static Analysis harder

But it has a very important lesson for us:

We should not analyze assembly based only on the name of the instructions, we should understand their semantics and their real effect on the CPU

And this is exactly our structure:

Assembly Basics
        ↓
Disassembly
         ↓
Instruction Semantics
         ↓
Obfuscation
         ↓
Deobfuscation

@reverseengine

Parent
چطور منتظر Child میمونه؟

تا اینجا دو تا از مهم‌ ترین قسمت‌ های Process API رو یاد گرفتیم:

fork() → ساخت Child

exec() → اجرای یک برنامه جدید داخل Child

حالا یک سؤال:

Parent
از کجا بفهمد Child کارش تموم شده؟

اینجاست که wait() وارد میشه




wait() چیکار میکنه؟

خیلی ساده:

wait()
باعث میشه Parent منتظر بمونه تا یکی از Child هاش تموم شه

مثلا:

Parent
│
├── fork()
│
▼
Child
│

├── کار خودش رو انجام میده
│
└── تموم میشه
│
▼
Parent ادامه میده

یعنی Parent نمیگه:

من دیگه کاری باهات ندارم



پس میگه:

کارت که تموم شد من ادامه میدم






یک مثال خیلی ساده:

فرض کنید یک برنامه داریم که میخاد یک Child بسازه:

pid = fork();

if (pid == 0) {
// Child
exec(...);
}
else {
// Parent
wait(...);
}

اینجا:

Child

برنامه جدید رو اجرا میکنه

Parent

با wait() منتظر میمونه

وقتی Child تموم شد Parent از wait() برمیگرده و اجرای خودش رو ادامه میده




چرا اصلا باید منتظر بمونیم؟

فرض کنید Shell رو باز کردید و مینویسید:

python test.py

اگر Shell بدون هیچ هماهنگی فورا کارهای بعدی رو انجام بده ممکنه خروجی و ترتیب اجرای برنامه‌ها چیزی نباشه که انتظار داریم

برای اجرای معمولی یک دستور Shell میتونه:

Child بسازه

2 برنامه رو داخل Child اجرا کنه
3 منتظر پایان Child بمونه
4 دوباره Prompt رو نمایش بده

تقریبا:

Shell
│
├── fork()
│
▼
Child
│
└── exec()
│
▼
Program
│
exit()
│
▼
Shell
│
▼
Prompt

یک نکته مهم:
wait() Process رو متوقف نمیکنه

اینجا یک اشتباه رایج وجود داره

وقتی Parent
wait()
میکنه به این معنی نیست که کل سیستم‌ عامل متوقف شده

فقط همون Process منتظر میمونه

CPU
میتونه در همین مدت
Process
های دیگه ای رو اجرا کنه

مثلا:

Parent → Waiting
Child → Running
Chrome → Running
Browser → Running

سیستم‌ عامل همچنان به بقیه Process ها CPU میده


اگر Child زودتر تموم بشه چی؟

اگر Child قبل از اینکه Parent به wait() برسه تموم شده باشه سیستم‌ عامل اطلاعات لازم مربوط به پایان Child رو نگه میداره تا Parent بتونه وضعیت پایان اون رو بگیره

اینجا به مفهوم مهمی به نام Zombie Process میرسیم

Zombie
یعنی Process ی که اجرای خودش رو تموم کرده اما هنوز Parent وضعیت پایان اون رو نگرفته

بعدا درباره Zombie و wait() دقیق‌ تر صحبت میکنیم


حالا سه‌ تایی اصلی رو کنار هم بذاریم

تا اینجا داریم:

fork()

ساختن Child:

Parent
↓
Child

exec()

جایگزین کردن برنامه داخل Child:

Child
↓
New Program

wait()

Parent

منتظر پایان Child میمونه:

Parent
↓
wait()
↓
Child finishes
↓
Parent continues

پس الگوی کلاسیک میشه:

Parent
│
fork()
│
▼
Child
│
exec()
│
▼
New Program
│
exit()
│
▼
Parent
│
wait()
│
▼
Continue

البته ترتیب دقیق wait() نسبت به اجرای Child به نحوه پیاده‌ سازی برنامه بستگی دارده این دیاگرام فقط الگوی مفهومی رو نشون میده




چرا این قسمت مهمه؟

وقتی یک برنامه رو روی Linux تحلیل میکنید و داخل کد به:

fork
exec
wait
exit

میخورید حالا میتونید حدس بزنید چه اتفاقی در حال رخ دادنه

مثلا:

fork()
↓
یک Process جدید
↓
exec()
↓
اجرای برنامه دیگه
↓
exit()
↓
wait()
↓
Parent ادامه میده

دیگه فقط اسم چند تابع رو نمیبینید منطق پشت اونها رو هم میفهمید



تا اینجا Process API رو با سه مفهوم اصلی یاد گرفتیم:

fork() → ساخت Child

exec() →
جایگزین کردن برنامه داخل Process

wait() →
انتظار Parent برای پایان Child

@reverseengine

How does Parent
wait for Child?

So far we have learned two of the most important parts of the Process API:

fork() → create Child

exec() → execute a new program inside Child

Now a question:

How does Parent
know when Child is finished?

This is where wait() comes in

What does wait() do?

Very simple:

wait()
makes Parent wait until one of its Children is finished

For example:

Parent
│
├── fork()
│
▼
Child
│

├── does its job
│
└── finishes
│
▼
Parent continues

That is, Parent does not say:

I have nothing more to do with you

So it says:

When the job is done, I will continue

A very simple example:

Suppose we have a program that wants to create a Child:

pid = fork();

if (pid == 0) {
// Child
exec(...);
}
else {
// Parent
wait(...);
}

Here:

Child

executes the new program

Parent

waits with wait()

When Child finishes, Parent returns from wait() and continues its execution

Why do we need to wait at all?

Suppose you open Shell and type:

python test.py

If Shell immediately executes the following tasks without any coordination, the output and execution order of the programs may not be what we expect

For a typical execution of a command Shell can:

Create a Child

2 Run the program inside the Child

3 Wait for the Child to finish

4 Display the Prompt again

Approximately:

Shell
│
├── fork()
│
▼
Child
│
└── exec()
│
▼
Program
│
exit()
│
▼
Shell
│
▼
Prompt

An important point:
wait() does not stop the Process

Here is a common mistake

When Parent
wait()
it does not mean that the entire operating system is stopped

Only that Process waits

The CPU can
execute other Processes

during the same time

For example:

Parent → Waiting
Child → Running
Chrome → Running
Browser → Running

The operating system still gives CPU to other processes

What if the Child terminates early?

If the Child has finished before the Parent reaches wait(), the operating system keeps the necessary information about the end of the Child so that the Parent can get its end status.

Here we come to an important concept called Zombie Process.

Zombie
is a Process that has finished executing but the Parent has not yet received its end status.

We will talk about Zombie and wait() in more detail later.

Now let's put the main three together.

So far we have:

fork()

Create Child:

Parent
↓
Child

exec()

Replace the program inside Child:

Child
↓
New Program

wait()

Parent Waits for the Child to finish:

Parent
↓
wait()
↓
Child finishes
↓
Parent continues
So the classic pattern becomes:

Parent
│
fork()
│
▼
Child
│
exec()
│
▼
New Program
│
exit()
│
▼
Parent
│
wait()
│
▼
Continue

Of course, the exact order of wait() in relation to Child execution depends on how the program is implemented. This diagram only shows the conceptual pattern.

Why is this part important?

When you analyze a program on Linux and you come across:

fork
exec
wait
exit

in the code, you can now guess what is happening.

For example:

fork()
↓
A new Process
↓
exec()
↓
Executing another program
↓
exit()
↓
wait()
↓
Parent continues.

You no longer just see the names of a few functions, you also understand the logic behind them.

So far, we have learned the Process API with three main concepts:

fork() → Creating a Child

exec() → Replacing a program inside a Process

wait() → Waiting for Parent to terminate Child

@reverseengine

The classic and official reference for ELF structure

https://refspecs.linuxfoundation.org/elf/gabi4+/contents.html

@reverseengine

Practical Binary Analysis

https://practicalbinaryanalysis.com

@reverseengine

The best of Reverse Engineering Reading List in world

https://github.com/onethawt/reverseengineering-reading-list

@reverseengine

How Trail of Bits helps verify the integrity of your Signal chats

https://blog.trailofbits.com/2026/08/11/how-trail-of-bits-helps-verify-the-integrity-of-your-signal-chats

@reverseengine

From Chrome renderer code exec to kernel with MSG_OOB

https://projectzero.google/2025/08/from-chrome-renderer-code-exec-to-kernel.html

@reverseengine