این تکنیک روی بخش‌هایی از کد که متغیرها در آن تعریف شده‌اند، عمل می‌کند. هر متغیری که تعریف می‌شود، دقیقا بعد از آن یک متغیر جدید با نام اصلی به علاوه پسوند _alias ساخته می‌شود. مثلاً اگر متغیری به نام count باشد، بلافاصله متغیری به نام count_alias تعریف می‌شود. نوع داده این متغیر جدید دقیقاً همان نوع متغیر اصلی است و مقدار اولیه‌اش به صورت مستقیم برابر با همان متغیر اصلی قرار می‌گیرد (مثل یک اشاره‌گر به مقدار همان متغیر).

from abgoosht_parser.c_ast import NodeVisitor

class AliasGenerator(NodeVisitor):
	pass

• توجه کنید که برای پیاده‌سازی این تکنیک شما صرفا مجاز به تغییر کلاس AliasGenerator از فایل alias_generator.py هستید.

این عملیات باید برای تمام متغیرهای تعریف‌شده در بدنه توابع انجام می‌شود. پس از اجرای این تکنیک، کدی تولید می‌شود که در آن هر متغیر، یک نسخه اضافی با نامی مشابه ولی پسوند _alias دارد که دقیقا همان مقدار و نوع را نگه می‌دارد. این باعث می‌شود تحلیل و درک نحوه استفاده از متغیرها سخت‌تر شود، زیرا چندین نام مختلف برای همان داده وجود دارد، اما عملکرد برنامه کاملاً بدون تغییر باقی می‌ماند. به مثال زیر از این تکنیک ابهام‌سازی توجه کنید:

• کد MIniC اولیه:

int main(){
    int a = 10;
    int b = 20;
    int c = a + b;
    printf("Hello world\n");
    return 0;
}

• کد مبهم شده با تکنیک AliasGenerator:

int main(){
    int a = 10;
    int a_alias = a;
    int b = 20;
    int b_alias = b;
    int c = a + b;
    int c_alias = c
    printf("Hello world\n");
    return 0;
}

• پس از ابهام سازی سه متغیر جدید با نام‌های a_alias,b_alias و c_alias به کد ساخته شده اضافه شده‌اند که مقادیری برابر با متغیر اصلی خود دارند و از یک نوع هستند.

این تکنیک روی عبارات محاسباتی در کد تمرکز دارد و تلاش می‌کند که عبارات ساده را به شکل‌های پیچیده‌تر ولی معادل تبدیل کند. هدف این است که نتیجه نهایی همان باشد ولی ظاهر کد پیچیده‌تر شود و خواندن آن سخت‌تر شود.

در این بخش تنها دو مورد از اعمال ریاضی مد نظر می‌باشند. در مواردی که عملگر جمع (+) در یک عبارت باینری دیده شود، آن عبارت به فرم معادلی تبدیل می‌شود که از عملیات بیت به بیت استفاده می‌کند: مقدار اصلی به صورت (left ^ right) + ((left & right) << 1) جایگزین می‌شود. در واقع عبارت a + b به (a XOR b) + ((a AND b) shifted left by 1) تغییر می‌کند که از نظر محاسباتی معادل جمع معمولی است اما نوشتار آن بسیار پیچیده‌تر است. در مواردی که عمل ضرب (*) بین یک عدد صحیح و مقدار 2 باشد، این عبارت با یک شیفت چپ (<< 1) معادل جایگزین می‌شود. برای مثال، 2 * x یا x * 2 تبدیل به x << 1 خواهد شد.

from abgoosht_parser.c_ast import NodeVisitor

class ExprComplexifier(NodeVisitor):
	pass

• توجه کنید که برای پیاده‌سازی این تکنیک شما صرفا مجاز به تغییر کلاس ExprComplexifier از فایل expr_complexifier.py هستید.

در نهایت توجه داشته باشید که از این تکنیک درهم‌سازی در این سوال فقط این دو مورد تبدیل مورد نیاز است و اگر عملگرهای دیگری دیده شوند یا شرایط فوق برقرار نباشد، عبارت بدون تغییر باقی می‌ماند. به مثال‌های زیر توجه کنید:

• کد MIniC اولیه:

int main(){
    int ans = 2 + 5;
    int output = ans * 2;
    return 0;
}

• کد مبهم شده با تکنیک ExprComplexifier:

int main(){
    int ans = (2 ^ 5) + ((2 & 5) << 1);
    int output = ans << 1;
    return 0;
}

• همانطور که مشاهده می‌کنید، پس از اعمال این روش ابهام‌سازی، عبارات ریاضی نسبت به کد اولیه پیچیده‌تر شده اما دقیقا از لحاظ مقدار اولیه یکسان می‌باشند.

این تکنیک درون بلوک‌های کد، بخصوص بخش‌هایی که چند دستور پشت سر هم قرار دارند، کدهایی اضافه می‌کند که هیچ‌گاه اجرا نمی‌شوند. این کدهای اضافه در این سوال، به شکل یک شرط if با شرط همیشه نادرست (if (0)) و یک حلقه for با شرط آغاز و پایانی که هیچ‌گاه وارد حلقه نمی‌شود (for (;0;)) هستند.

from abgoosht_parser.c_ast import NodeVisitor

class DeadCodeInserter(NodeVisitor):
	pass

• توجه کنید که برای پیاده‌سازی این تکنیک شما صرفا مجاز به تغییر کلاس DeadCodeInserter از فایل dead_code.py هستید.

این دو کد مرده (Dead Code) به شکل زیر خواهند بود:

• شرط if با مقدار و بدنه 0 که هیچ‌گاه اجرا نخواهد شد و تغییری در ساختار اصلی کد به وجود نخواهد آورد:

if (0)
{
    0;
}

• حلقه for با بدنه‌ای خالی که هیچ‌گاه اجرا نخواهد شد و این کد مرده نیز تغییری در ساختار اصلی کد به وجود نیاورده اما باعث پیچیده‌تر شدن و ناخواناتر شدن کد می‌شود:

for (; 0;)
{
}

توجه داشته باشید که در تکنیکی که در این سوال پیاده‌سازی می‌کنید، باید دقیقا در ابتدای هر بلاکی که دارای بدنه است (مانند for بالا بدنه‌اش خالی نیست) یک شرط مرده و دقیقا در انتهای بلاک یک شرط حلقه مرده را اضافه کند. به مثال زیر از ابهام‌سازی کد توجه کنید:

• کد MIniC اولیه:

int main(){
    int ans = 2 + 5;
    int output = ans * 2;
    if(ans > 10){
        ans = 10;
    }
    print(output);
    return 0;
}

• کد مبهم شده با تکنیک DeadCodeInserter:

int main(){
    if (0)
    {
        0;
    }
    int ans = 2 + 5;
    int output = ans * 2;
    if(ans > 10){
        if (0)
        {
            0;
        }
        ans = 10;
        for (; 0;)
        {
        }
    }
    print(output);
    return 0;
    for (; 0;)
    {
    }
}

• همانطور که مشاهده می‌گنید، در کد مبهم شده در ابتدای هر بلاک کد یک شرط if مرده و در انتهای هر بلاک کد یک حلقه for مرده درج شده است که خوانایی کد را کاهش اما عملکرد کد را نسبت به کد اولیه بدون تغییر نگه می‌دارد.

در این تکنیک مبهم‌سازی باید ابتدا، تابع‌های کمی تا حدودی بزرگ (یعنی توابعی که بیش از دو دستور دارند)، به دو بخش تقریباً مساوی تقسیم می‌شوند. نیمه‌ی اول همان بدنه‌ی اصلی تابع باقی می‌ماند و نیمه‌ی دوم در یک تابع جدید با نامی مشتق‌شده از نام تابع اصلی (دقیقا به شکل <نام_تابع>_split_<شمارنده>) قرار می‌گیرد. این تابع کمکی جدید باید تمامی پارامترهای تابع اصلی را به همراه متغیرهایی که در نیمه دوم استفاده شده‌اند اما در نیمه اول تعریف شده‌اند، به عنوان پارامتر دریافت کند.

from abgoosht_parser.c_ast import NodeVisitor

class FunctionSplitter(NodeVisitor):
	pass

• توجه کنید که برای پیاده‌سازی این تکنیک شما صرفا مجاز به تغییر کلاس FunctionSplitter از فایل function_splitter.py هستید.

توجه داشته باشید که نام تابع کمکی و پارامترهای اضافه باید دقیقاً مطابق این الگو ساخته شوند تا در سیستم داوری قابل تشخیص باشند. پارامترهای اضافه شده باید از نوع و مشخصات همان متغیرهای اصلی کپی می‌شوند، بدون ایجاد تغییرات اضافه‌ای که در سیستم داوری مورد پذیرش قرار نخواهند گرفت. تابع اصلی باید پس از اجرای نیمه اول، با ارسال پارامترهای لازم، تابع کمکی را فراخوانی کند. اگر نوع بازگشتی تابع اصلی غیر void باشد، فراخوانی تابع کمکی باید در یک دستور بازگشت (return) قرار گیرد، در غیر این صورت فقط فراخوانی به تنهایی در بدنه اضافه می‌شود.

نتیجه نهایی، کدی است که ساختار توابع بزرگ را به مجموعه‌ای از توابع کوچک‌تر تقسیم می‌کند که با یکدیگر در تعامل‌اند. این کار باعث می‌شود درک جریان کنترل و ردیابی مقادیر در کد دشوارتر شود، بدون آنکه منطق برنامه تغییر کند. به مثال زیر از این روش ابهام‌سازی توجه کنید:

• کد MIniC اولیه:

int add_and_print(int a, int b) {
    int sum = a + b;
    int square = sum * sum;
    printf("sum: %d\n", sum);
    printf("square: %d\n", square);
    return sum;
}

• کد مبهم شده با تکنیک FunctionSplitter:

int add_and_print_split_0(int a, int b, int sum, int square)
{
    printf("sum: %d\n", sum);
    printf("square: %d\n", square);
    return sum;
}

int add_and_print(int a, int b)
{
    int sum = a + b;
    int square = sum * sum;
    return add_and_print_split_0(a, b, sum, square);
}

• در مثال بالا، تابع اولیه add_and_print به دو تابع تقسیم شده است. تابع اولیه add_and_print که پارامتر‌ها و خروجی‌اش تغییری نکرده است و تابع add_and_print_split_0 که نیمه‌ی دوم کد‌های بدنه‌ی تابع اولیه را داراست. به این صورت، کد اولیه به دو تابع تقسیم شده که تحلیل و خواناییش را کاهش می‌دهد.

در این تکنیک، در هر بلوک کد که مجموعه‌ای از دستورات را در خود دارد (و بلوکی با بدنه خالی نیست)، دقیقاً یک کامنت گمراه‌کننده از بین کامنت‌های زیر اضافه خواهد شد. متن کامنت از بین قالب‌های ثابت و مشخص انتخاب می‌شود و به شکل زیر خواهند بود:

• // optimization level={}

• // todo: refactor this loop

• // warning: potential overflow at line {}

• // debug: value of x is unknown

• // temporary hack, remove later

همانطور که مشاهده می‌کنید، کامنت‌های اول و سوم دارای یک Placeholder می‌باشند، که باید با یک مقدار عددی جایگزین شوند. مقدار عددی این شمارنده در ابتدا از مقدار 0 شروع شده و با مشاهده هر بلاک کد که خالی نباشد، مبهم‌سازی شما باید به ترتیب و به صورت چرخشی هر کدام از کامنت‌ها را در ابتدای آن بلاک کد درج کرده و مقدار شمارنده را یکی افزایش دهد.

from abgoosht_parser.c_ast import NodeVisitor

class MisleadingComments(NodeVisitor):
	pass

• توجه کنید که برای پیاده‌سازی این تکنیک شما صرفا مجاز به تغییر کلاس MisleadingComments از فایل misleading_comments.py هستید.

این کامنت‌ها به صورت رشته متنی در ابتدای هر بلاک کد به گونه‌ای درج می‌شود که ترتیب اجرای دستورات تغییر نکند. هدف این تکنیک افزودن کامنت‌هایی است که هیچ ارتباط واقعی یا فنی با کد ندارند و صرفاً باعث گمراه کردن خواننده یا تحلیل‌گر کد می‌شوند، بدون اینکه تاثیری روی عملکرد برنامه داشته باشند. به مثال زیر توجه کنید:

• کد MIniC اولیه:

void compute(int n) {
    int sum = 0;
    for (int i = 0; i < n; i++) {
        sum += i;
    }

    if (sum > 50) {
        printf("Large sum: %d\n", sum);
    } else {
        printf("Small sum: %d\n", sum);
    }

    while (sum > 0) {
        sum--;
    }

    {
        int temp = sum * 2;
        printf("Temp: %d\n", temp);
    }
}

int main() {
    compute(10);

    {
        int a = 5;
        int b = 10;
        if (a < b) {
            printf("a < b\n");
        }
    }

    return 0;
}

• کد مبهم شده با تکنیک MisleadingComments:

void compute(int n)
{
    // optimization level=5;
    int sum = 0;
    for (int i = 0; i < n; i++)
    {
        // optimization level=0;
        sum += i;
    }

    if (sum > 50)
    {
        // todo: refactor this loop;
        printf("Large sum: %d\n", sum);
    }
    else
    {
        // warning: potential overflow at line 2;
        printf("Small sum: %d\n", sum);
    }
    while (sum > 0)
    {
        // debug: value of x is unknown;
        sum--;
    }

    {
        // temporary hack, remove later;
        int temp = sum * 2;
        printf("Temp: %d\n", temp);
    }
}

int main()
{
    // debug: value of x is unknown;
    compute(10);
    {
        // warning: potential overflow at line 7;
        int a = 5;
        int b = 10;
        if (a < b)
        {
            // todo: refactor this loop;
            printf("a < b\n");
        }
    }
    return 0;
}

• در مثال بالا، ترتیب چرخشی درج کامنت‌ها و کامنت‌هایی که دارای Placeholder هستند مشخص شده است. توجه داشته باشید که این ترتیب، بر اساس ترتیب پیمایش dfs ای بر روی ساختار درخت AST کد می‌باشد. به همین دلیل است که اولین کامنت بیهوده افزوده شده، کامنت // optimization level=0; می‌باشد.

در این تکنیک، تمامی نام‌های متغیرهای محلی و پارامترهای توابع به‌صورت کامل بازنام‌گذاری می‌شوند به طوری که هر نام یکتا به یک نام جدید با طول دقیقا هشت حرف انگلیسی (حروف بزرگ و کوچک) تبدیل می‌شود. این بازنام‌گذاری ثابت است؛ یعنی هر بار که یک نام مشخص در کد دیده شود، به همان نام جدید اختصاص یافته تغییر می‌یابد و تمامی ارجاعات به آن متغیر در جایگاه‌های مختلف کد نیز اصلاح می‌شود. نکته مهم این است که نام توابع تغییر نمی‌کند و فقط متغیرها و پارامترهای توابع تحت این تبدیل قرار می‌گیرند.

from abgoosht_parser.c_ast import NodeVisitor

class VariableRenamer(NodeVisitor):
	pass

• توجه کنید که برای پیاده‌سازی این تکنیک شما صرفا مجاز به تغییر کلاس VariableRenamer از فایل rename_vars.py هستید.

نام‌های جدید کاملاً تصادفی ساخته می‌شوند، مثلاً به شکل AbcDefGh، اما در کل برنامه ثابت و یکسان باقی می‌مانند تا رفتار کد حفظ شود و فقط ابهام در نامگذاری متغیرها ایجاد شود. این روش باید به‌گونه‌ای پیاده‌سازی شود که هیچ تغییری در ساختار و عملکرد اصلی برنامه رخ ندهد و تنها باعث گمراهی خواننده کد از طریق تغییر اسامی متغیرها شود.

• کد MIniC اولیه:

int add(int a, int b) {
    int sum = a + b;
    int square = sum * sum;
    printf("sum=%d, square=%d\n", sum, square);
    return sum;
}

int main() {
    int x = 5;
    int y = 10;
    int result = add(x, y);
    printf("result=%d\n", result);
    return 0;
}

• کد مبهم شده با تکنیک VariableRenamer:

int add(int hQZrHNIb, int aAblsZPU)
{
    int nZqxayZQ = hQZrHNIb + aAblsZPU;
    int KMgwRWmn = nZqxayZQ * nZqxayZQ;
    printf("sum=%d, square=%d\n", nZqxayZQ, KMgwRWmn);
    return nZqxayZQ;
}

int main()
{
    int iNVTbmjf = 5;
    int rcfEdJgf = 10;
    int yhEbwcjU = add(iNVTbmjf, rcfEdJgf);
    printf("result=%d\n", yhEbwcjU);
    return 0;
}

• همانطور که در مثال بالا مشاهده می‌کنید، اسامی تمامی متغیر‌ها و پارامتر‌های توابع و همچنین تمام استفاده‌های آن‌ها در کد بازنویسی شده‌اند و به رشته‌هایی با مقادیر تصادفی تبدیل شده‌اند تا خوانایی کد را کاهش دهند.

در این تکنیک مبهم‌سازی، جریان کنترل در تابع اصلی (تابع main) به صورت عادی دنبال نمی‌شود، بلکه به کمک یک متغیر وضعیت (State variable) و یک ساختار switch-case درون یک حلقه‌ی بی‌نهایت بازنویسی می‌شود. در ابتدای بدنه تابع، یک متغیر جدید به نام __cf_state تعریف و مقدار اولیه‌ی آن صفر قرار داده می‌شود. هر دستور در بدنه‌ی اصلی تابع به یک case متناظر تبدیل می‌شود که در آن، ابتدا دستور اصلی اجرا شده و سپس مقدار متغیر __cf_state به شماره‌ی دستور بعدی تغییر می‌کند.

در این ساختار، یک switch روی مقدار __cf_state وجود دارد که مشخص می‌کند کدام بخش از کد باید اجرا شود. این switch داخل یک حلقه‌ی while(1) قرار داده می‌شود تا پس از هر تغییر وضعیت، اجرای دستورات بعدی ادامه پیدا کند. در مواردی که یک دستور از نوع return باشد، دیگر نیازی به تغییر وضعیت نیست و همانجا جریان اجرا خاتمه پیدا می‌کند.

from abgoosht_parser.c_ast import NodeVisitor

class ControlFlowFlattener(NodeVisitor):
    pass

• توجه کنید که برای پیاده‌سازی این تکنیک شما صرفا مجاز به تغییر کلاس ControlFlowFlattener از فایل control_flow_flattener.py هستید.

به این ترتیب، ساختار اصلی کد به جای توالی ساده‌ای از دستورات، به یک ماشین حالت (State Machine) تبدیل می‌شود که دنبال کردن جریان اجرای آن برای انسان و ابزارهای تحلیل ایستا بسیار دشوارتر است. این کار بدون تغییر در منطق برنامه، باعث افزایش سطح ابهام و سخت‌تر شدن درک اجرای واقعی کد می‌شود. به مثال ساده زیر توجه کنید:

• کد MIniC اولیه:

int main() {
    int a = 5;
    int b = 10;
    return a + b;
}

• کد مبهم شده با تکنیک ControlFlowFlattener:

int main() {
    int __cf_state = 0;
    while (1) {
        switch(__cf_state) {
            case 0:
                a = 5;
                __cf_state = 1;
                break;
            case 1:
                b = 10;
                __cf_state = 2;
                break;
            case 2:
                return a + b;
        }
    }
}

• این روش مبهم‌سازی، کد بسیار ساده‌ی اولیه را به ماشین حالتی تبدیل کرده است که دقیقا همان عملکرد را در سطح کد خواهد داشت اما خوانایی و دنبال کردن جریان اجرای کد را بسیار پیچیده کرده است.

در این تکنیک مبهم‌سازی هر دستور ساده داخل بلاک‌های کد (دستوراتی که جزو دستورات if, while, return, break, continue, switch و تعریف متغیر‌ها نیستند) به‌جای اینکه مستقیماً اجرا شود، داخل یک شرطِ همیشه‌صادق 1 == 1 قرار می‌گیرد تا خواندن و تحلیل کد سخت‌تر شود. همهٔ دستورات واجد شرایط (غیر از مواردی که پیش‌تر اشاره شد) همیشه و بدون تغییر اضافه‌تری با یک if احاطه می‌شوند. شرط if مورد استفاده ثابت و ساده است (1 == 1) تا رفتار اجرا هیچ‌گاه تغییر نکند ولی ساختار کد پیچیده‌تر و پر از شاخه‌های بی‌اثر شود.

from abgoosht_parser.c_ast import NodeVisitor

class OpaquePredicate(NodeVisitor):
    pass

• توجه کنید که برای پیاده‌سازی این تکنیک شما صرفا مجاز به تغییر کلاس OpaquePredicate از فایل opaque_predicate.py هستید.

تبدیل باعث می‌شود بلوک‌های کد با شاخه‌های بی‌اثر و شرط‌های همیشه‌حقیقی احاطه شوند؛ این امر خوانایی و تحلیل ایستا را کاهش می‌دهد بدون اینکه منطق یا جریان دادهٔ برنامه تغییر کند. چنین تغییری برای ابزارهای سادهٔ آنالیز یا بررسی دستی، ردیابی مسیرهای اجرا و یافتن رابطهٔ بین دستورها را دشوارتر می‌کند. به مثال تغییر پیش و پس از اِعمال این تکنیک توجه کنید:

• کد MIniC اولیه:

int main() {
    int a = 5;
    int b = 10;
    int c = a + b;
    printf("%d\n", c);
    return 0;
}

• کد مبهم شده با تکنیک OpaquePredicate:

int main() {
    int a = 5;
    int b = 10;
    int c = a + b;
    if (1 == 1) {
        printf("%d\n", c);
    }
    return 0;
}

• در کد ابهام شده، می‌توان مشاهده کرد که تنها دستور printf توسط یک شرط if همیشه درست ابهام شده و دستورات دیگر به دلیل اینکه تعاریف متغیر‌ها هستند، بی تغییر باقی مانده‌اند.