Python Program Obfuscation Tool

Mục đích thiết kế chương trình: Mục tiêu chính của dự án là phát triển một công cụ làm rối mã nguồn chương trình Python đa nền tảng, công cụ này có thể dễ dàng bảo vệ mã nguồn cho những người muốn bảo vệ quyền sở hữu trí tuệ của họ hoặc quản lý thuật toán nhạy cảm của phần mềm. Công cụ này sẽ làm rối và mã hóa liền mạch mã nguồn thành dữ liệu byte mà trình thông dịch Python có thể thực thi được, dữ liệu này có thể được trộn lẫn và thực thi với chương trình Python thông thường. Ngoài ra, nó sẽ cung cấp một bộ giải mã để hoàn nguyên dữ liệu byte bị làm rối trở lại mã nguồn ban đầu. Chương trình bao gồm ba thành phần chính:

• Bộ mã hóa làm rối: Thành phần này mã hóa mã nguồn Python, cho dù đó là toàn bộ tệp hay một phần cụ thể, khiến nó không thể đọc được dưới dạng dữ liệu byte, sau đó nhúng một tiêu đề thực thi để tạo chương trình/phần Python có thể thực thi nhưng không thể đọc được.

• Bộ giải mã làm rối: Bộ giải mã được thiết kế để đảo ngược quá trình mã hóa, bộ giải mã này chuyển đổi dữ liệu byte bị làm rối trở lại mã Python ban đầu, đảm bảo dễ đọc và dễ truy cập.

• Giao diện Web dịch vụ: Cung cấp giao diện web thân thiện với người dùng để người dùng dễ dàng mã hóa và giải mã các chương trình Python.

Ví dụ về cách sử dụng công cụ làm rối chương trình được hiển thị bên dưới, người dùng có thể sử dụng bộ mã hóa để làm rối mã một dòng print("hello world") thành các byte mã không thể đọc được, sau đó sử dụng bộ giải mã để chuyển đổi lại:

Figure 00: Code obfuscation encode and decode example, version v_0.1.3 (2025)

Chúng tôi cũng cung cấp Python-API để người dùng tích hợp chức năng mã hóa và giải mã & thực thi theo thời gian thực vào chương trình của họ. Video hiển thị chi tiết cách sử dụng: link

# Created:     2024/03/21
# Version:     v_0.1.3
# Copyright:   Copyright (c) 2024 LiuYuancheng
# License:     MIT License

--------------------------------------------------------------------------------------------------

Giới thiệu

Làm rối chương trình là một kỹ thuật phổ biến được áp dụng rộng rãi để tăng cường bảo mật cho các ứng dụng Python. Có nhiều thư viện và công cụ làm rối mã nguồn tồn tại trên thị trường, chẳng hạn như pyarm hoặc công cụ làm rối mã nguồn trực tuyến miễn phí. Quá trình làm rối mã nguồn sẽ sử dụng các phương pháp như identifier renaming, code encryption, code packing, dead code insertion, v.v., nó khiến tin tặc khó hiểu luồng thực thi/điều khiển chương trình và bảo vệ mã nguồn nhạy cảm khỏi truy cập trái phép một cách hiệu quả. Nhưng hầu hết các công cụ làm rối mã nguồn hiện tại không cung cấp các tính năng như decoding algorithms, customization of obfuscation result size hoặc selection of whether obfuscate entire/part of file.

Lấy cảm hứng từ khái niệm của công cụ làm rối mã nguồn trực tuyến miễn phí này, mục tiêu của chúng tôi là phát triển một công cụ làm rối chương trình Python dựa trên web với các tính năng chính sau:

• Cung cấp khả năng làm rối mã Python nhiều lớp với cấu hình kích thước mã bị làm rối được mã hóa tùy chỉnh.

• Cung cấp cả chức năng mã hóa và giải mã để tạo điều kiện bảo trì và gỡ lỗi mã bị làm rối.

• Cung cấp khả năng làm rối toàn bộ chương trình Python hoặc các phần cụ thể của mã nguồn để tăng thêm tính linh hoạt.

• Tích hợp các kỹ thuật ngẫu nhiên hóa mã linh hoạt để đảm bảo rằng mỗi mã bị làm rối được tạo ra là duy nhất, ngay cả khi có nguồn gốc từ cùng một mã nguồn.

• Cung cấp API tiêu chuẩn để người dùng tích hợp liền mạch công cụ vào các dự án của họ, cùng với giao diện người dùng Web thân thiện để vận hành mã hóa và giải mã thuận tiện.

Quy trình làm việc của công cụ làm rối mã nguồn được hiển thị bên dưới:

Figure 01: Code obfuscation encode and decode work flow, version v_0.1.3 (2025)

Giao diện người dùng Web của bộ mã hóa làm rối

Trang Bộ mã hóa làm rối được hiển thị bên dưới. Để làm rối một hàm hoặc chương trình Python, chỉ cần dán mã nguồn Python vào trường văn bản mã nguồn, sau đó chọn tham số cấu hình nối nội dung ngẫu nhiên randomLen (trong khoảng từ 0 đến 100). Mỗi dòng mã nguồn sẽ được nối randomLen * 16 Bytes chuỗi ngẫu nhiên trước khi thực hiện quá trình mã hóa làm rối.

Chế độ xem trang web của bộ mã hóa làm rối:

Figure 02: Code obfuscation webApp encoder screen shot, version v_0.1.3 (2025)

Sau khi nhấn nút "Run Obfuscation Encode", mã bị làm rối sẽ xuất hiện trong trường văn bản kết quả ở bên phải. Nhấn nút sao chép mã, sau đó dán mã bị làm rối vào chương trình của bạn để thực thi.

Lưu ý: Mỗi khi người dùng nhấn nút chạy, một kết quả mã bị làm rối khác sẽ được tạo.

Giao diện người dùng Web của bộ giải mã làm rối

Tương tự như trang bộ mã hóa, trang bộ giải mã được hiển thị bên dưới. Người dùng phải sao chép dữ liệu byte của mã bị làm rối (chứa trong hàm exec()) vào trường văn bản bên trái. Sau đó, bằng cách nhấp vào nút "Run Decoder", mã bị làm rối sẽ được chuyển đổi trở lại mã nguồn ban đầu.

Figure 03: Code obfuscation webApp decoder screen shot, version v_0.1.3 (2025)

Lưu ý: Nếu người dùng muốn lấy mã nguồn mà không có nhận xét, họ có thể đánh dấu vào hộp kiểm "Remove the comments".

--------------------------------------------------------------------------------------------------

Kiến thức nền tảng

Làm rối chương trình là gì?

Làm rối chương trình là một kỹ thuật được sử dụng trong phát triển phần mềm để cố ý làm cho mã nguồn của một chương trình khó hiểu hoặc thiết kế ngược hơn, đồng thời vẫn giữ nguyên chức năng của nó. Nó thường được sử dụng trong các trường hợp mà nhà phát triển muốn bảo vệ quyền sở hữu trí tuệ của họ, ngăn chặn truy cập trái phép hoặc cản trở các nỗ lực can thiệp vào phần mềm.

Dưới đây là một số kỹ thuật phổ biến được sử dụng trong làm rối chương trình:

1. Đổi tên định danh: Điều này liên quan đến việc đổi tên các biến, hàm, lớp và các định danh khác trong mã thành các tên không mô tả hoặc khó hiểu. Ví dụ: các biến như userInput có thể được đổi tên thành a hoặc b, khiến người khác khó hiểu mục đích của chúng hơn.

2. Làm rối luồng điều khiển: Kỹ thuật này liên quan đến việc thay đổi luồng điều khiển trong chương trình, khiến người khác khó theo dõi cấu trúc logic hơn. Điều này có thể đạt được thông qua các kỹ thuật như thêm mã dư thừa, sử dụng các câu lệnh điều kiện theo những cách khác thường hoặc tái cấu trúc các vòng lặp.

3. Làm rối dữ liệu: Làm rối dữ liệu liên quan đến việc ngụy trang dữ liệu trong chương trình, khiến người khác khó hiểu hoặc trích xuất thông tin nhạy cảm hơn. Điều này có thể bao gồm mã hóa chuỗi hoặc chia chúng thành các phần nhỏ hơn được nối tại thời điểm chạy.

4. Mã hóa mã: Điều này liên quan đến việc mã hóa một số hoặc tất cả mã trong chương trình và giải mã nó tại thời điểm chạy. Điều này gây khó khăn cho những kẻ tấn công trong việc phân tích mã mà không cần biết khóa giải mã.

5. Chèn mã chết: Chèn mã chết (mã không bao giờ được thực thi) vào chương trình có thể gây nhầm lẫn cho các kỹ sư thiết kế ngược và khiến người khác khó hiểu chức năng thực sự của chương trình hơn.

6. Đóng gói mã: Điều này liên quan đến việc nén hoặc đóng gói tệp thực thi, khiến người khác khó phân tích bằng các công cụ tiêu chuẩn hơn. Mã được đóng gói thường được giải nén và thực thi tại thời điểm chạy.

7. Các kỹ thuật chống gỡ lỗi: Đây là các phương pháp được sử dụng để phát hiện và ngăn chương trình bị gỡ lỗi, điều này có thể gây khó khăn cho những kẻ tấn công trong việc phân tích mã.

Điều quan trọng cần lưu ý là mặc dù làm rối mã nguồn có thể gây khó khăn hơn cho việc thiết kế ngược, nhưng nó không phải là một phương pháp hoàn hảo để bảo vệ phần mềm. Những kẻ tấn công lành nghề vẫn có thể thiết kế ngược mã bị làm rối nếu có đủ thời gian và tài nguyên. Do đó, làm rối mã nguồn thường được sử dụng kết hợp với các biện pháp bảo mật khác như mã hóa, kiểm soát truy cập và ký mã. Ngoài ra, mã bị làm rối có thể khó bảo trì và gỡ lỗi hơn, vì vậy các nhà phát triển nên cân nhắc lợi ích so với những nhược điểm tiềm ẩn trước khi áp dụng các kỹ thuật làm rối mã nguồn.

--------------------------------------------------------------------------------------------------

Thiết kế dự án

Phần này tích hợp với kiến thức nền tảng để làm sáng tỏ các bước và kỹ thuật được áp dụng trong quá trình làm rối mã nguồn.

Thiết kế mã hóa và giải mã

Như được mô tả trong sơ đồ quy trình làm việc của chương trình được cung cấp trong phần giới thiệu, phần mã nguồn Python trải qua quá trình mã hóa thông qua một loạt các bước để chuyển đổi chuỗi mã nguồn Python thành dữ liệu byte. Sau đó, nó được đóng gói với một tiêu đề giải mã. Để thực thi dữ liệu byte, tiêu đề giải mã được sử dụng để chuyển đổi byte trở lại thành một chuỗi, sau đó được chuyển vào hàm thực thi mã động Python exec() để thực thi mã. Các bước mã hóa được nêu dưới đây:

Ví dụ về đầu vào mã nguồn của bộ mã hóa:

import os
# Code comment 1
print("Current working directory is : %s" % os.getcwd())
dirpath = ''
# Code document 2
if os.path.dirname(__file__):
      dirpath = os.path.dirname(__file__)
else:
      dirpath = os.getcwd()
# Code comment 3
print("Current source code location : %s" % dirpath)
print("Hello world")

Ví dụ về đầu ra mã bị làm rối của bộ mã hóa:

def obfDecode(data): return __import__('zlib').decompress(__import__('base64').b64decode(data[::-1]))
exec(obfDecode(b'kDMA2910OfmOY0xz1Jeq1cjF1JMlFPYhZCtLm5r5V0c3LyNFMwBmnV7YF3hnto2YOMsfrKkvLSzKTp1tL3je1dP+R8t2mH74DVtheP0G1EUMVMnsRP3APWbRcAfFkilrWTbnlp3ttZVjhXcluBz5GOMb/UlK2UKJRzbbUXHe7DKL65v/y/trHOP3hfqE83kkRwle1v6OSgbVVAT7CZvvXGXWa6u6wBXjGgHPV02VULPoNfXFUXRCUxN11+ZFIxbON+t67wffylf9V3/xKJxHbe96nWPH/3aBwKW0e9GFl5DlK4zJUCSNqnhxlGpiCVNIKCHTC2uuOvPgUNLjQXiOJWJbRbEnW/YfrDQrsX9eUPX+tT4w6hx10UIIG2U7zcC2maRyDUhYcjeEeMOVjqHUR/aZTjtcVuOJ0GjIzrjqdau0yCup99y2Hov6/TZyKf/JPXmd1M+6IMyrPBpVuw8uBVYW72TRSDh1o1F2OuFvl05d1HhzjFYOuiuSqq+58tbop9aXeMV/lzj02klznW10GVcXSYESwFoLEcLoStyQaVw72AYC9UNEqEhvYgvGJizlmu1QsDmIhOcq1M3ViI2UV9/6Hrf55PtrZWqMfX0CF3YFPWI20OQmE4FjWKTHwduZ+wMzweDKqrBNbhWwj6GL6srBRXvVZvVAiyV+WNUAs8n3u/uPlbv7u/Ok6/4vU9jPP+1Dyme57KhvsRITjAGw1AakCa8M+oVb7C7IZ0pRFn8xyVdXmJRlRwoduC6hR/cuwBZUHCjScdDhB4I0G81XqP+/PIvAGmFho19mLzJCyZ94+m1k7trz3/QUzBQ0h0oJhbaeEOhzrBm15OrFoXuiATAG3TpdTH0Jqud75vO/97ffXQsSeG7Az9GP55p5moVcW4AZxQt+3pDQtfJeYVwSU3kh6jJNyuApFffdvFQdytMKCJGO9OLnjnWf+fPe3uvPzFO852U+Vnu58HP/pX+8P3+6nT/tukz8xX+x2X/2zH123+6pV7O/4Lf7Ln+492o77mrhGcdXegy4lyiNQJnIiRrIqRx9Vf+eJTdEbR0B1yoxwskbtt7SYIWLoujaBPnJYb+oGzH+5/wDvmN5rd68rP9g1gmsgROkfKzZgg/k0ZjoPgwZmWzkwtXgZCngFcnu1eKchFyUMpbHjJgR3QGnL6IKemRn6JX/+4Lf2X/yhXe0ff0RK9Hc5urkwNBs3d02Jz4ZmO9Mmw5roHzbmIvsZUSVKlKGejtxGfYeNcfhMcEXK2Ml1xJe'))

Kỹ thuật làm rối mã nguồn được sử dụng trong quá trình mã hóa làm rối:

1. Đảo ngược byte: Mảng byte dữ liệu kết quả được đảo ngược để làm cho mã bị đảo ngược khó hiểu hơn trong nháy mắt và yêu cầu đảo ngược nó trước khi diễn giải nó một cách chính xác.

2. Ngẫu nhiên hóa: Hàm mã hóa thêm một chuỗi ngẫu nhiên có độ dài được chỉ định vào mỗi dòng trước khi làm rối mã nguồn. Điều này làm tăng thêm sự phức tạp và ngẫu nhiên cho mã bị làm rối.

3. Nhập động: Mã bị làm rối sử dụng __import__() để nhập động các mô-đun (zlib và base64). Kỹ thuật này ẩn các lần nhập, làm cho nó ít rõ ràng hơn về các mô-đun đang được sử dụng.

4. Thao tác chuỗi: Quá trình mã hóa loại bỏ các nhận xét, chuỗi tĩnh và dòng trống khỏi mã để làm cho mã trở nên khó hiểu và phân tích hơn.

5. Mã hóa và nén: Hàm mã hóa làm rối mã bằng cách mã hóa nó bằng base64 và nén nó bằng zlib. Ngoài ra, nó đảo ngược chuỗi kết quả. Quá trình này làm cho mã không thể đọc được ở dạng được mã hóa của nó.

6. Thực thi thông qua exec(): Mã được thực thi bởi hàm exec(). Phương pháp thực thi này gây khó khăn cho việc hiểu hành vi của mã mà không cần phân tích quá trình thực thi của nó.

Các kỹ thuật làm rối mã nguồn này làm cho mã khó hiểu, phân tích và thiết kế ngược, tăng cường khả năng chống lại thiết kế ngược và truy cập trái phép.

Quá trình giải mã đảo ngược quá trình mã hóa với các bước dưới đây:

Ví dụ về đầu vào byte bị làm rối của bộ giải mã:

b'==Azg/E+Hk/eC9JOcaYt02SskKCJHfYu6ZVAPyhHdaUjsOse30tA1QP7d3nvW7U4eWbcNtHxmP4jG6VKRiMCbBNe1/8UHBxw7WSMdLdeA6vnz07MBSDeOxNd91GOps8hieqUrq+9QO8BIrlwh1me8uwTqOvK7qNLgbc/bAsiysVCPPfoDwOxAE+YpjwxPvGPaBCdTP2QWyRuO36o4GRlaf8NtENhd5Uzcz6VcBntUaz73kkqyNxjXKCvrqFH2Cy5pc12ydzjuIS2p2ERKLy1IA0LZdHllai3el3/e4VY40KhjXeZkjmtgMmJxAyQ4wDgWPWqXiNfywoHb2OWVBA442CkfaqknK/aDE4exCL2PGERtupfoaVAgikXMR/ZdA2NkxKhO19JWowZYU0I8GSzd7mwOI6S+6C8r4ZwVAj12P+t5OUnvkVvx1lxRGXFxyh8FaFglYml1iilkUBzBrsTI24q2VgoCr5bA1nvSNdY8hbXvZBRS05i9YWwlQGzbgB15Qlcnh6Wb0aYxUVMrT58MYXngucLlVZVvACQdIr2YTFBjwlN5aslybv/Pf/zeML/+4zvjs9x1v+P+97fe8rP+9867fe++3v++fuO6uloQpnGAp9n2CEh7cmhi43pvoPpZK5ThFO7GeeRQETHqtkk1xJe'

Ví dụ về đầu ra mã nguồn của bộ giải mã:

print("hello world")

--------------------------------------------------------------------------------------------------

Thiết lập chương trình

Thực hiện theo các bước cấu hình bên dưới trước khi chạy chương trình.

Môi trường phát triển

• python 3.8.2rc2+ [Windows11]

Lib/Phần mềm bổ sung cần thiết

• Flask: https://flask.palletsprojects.com/en/3.0.x/, cài đặt pip install Flask

• Flask-SocketIO: https://flask-socketio.readthedocs.io/en/latest/, cài đặt pip install Flask-SocketIO

Phần cứng cần thiết: Không có

Danh sách tệp chương trình

--------------------------------------------------------------------------------------------------

Cách sử dụng/thực thi chương trình

Chúng tôi cung cấp hai giao diện để người dùng sử dụng chương trình: giao diện lệnh bảng điều khiển và giao diện web.

Chạy bộ làm rối mã nguồn thông qua giao diện lệnh

Bước 1: Chạy chương trình thông qua lệnh:

python pyObfuscator.py

Bước 2: Chọn chế độ 0, sau đó làm theo các bước để nhập chương trình Python cần làm rối, mã bị làm rối sẽ được lưu trong tệp obfuscateCode.py, sau đó người dùng có thể thay đổi tên của tệp và thay thế tệp gốc.

Figure 03: obfuscator test case usage screen shot, version v_0.1.3 (2025)

Chạy bộ làm rối mã nguồn thông qua giao diện web

Bước 1: Chạy chương trình máy chủ web thông qua lệnh:

python pyObfuscatorApp.py

Bước 2: Mở trình duyệt nhập URL: http://127.0.0.1:5000/

Figure 04: Code obfuscation webApp introduction page screen shot, version v_0.1.3 (2025)

Bước 3: Chọn Obfuscation Encoder từ menu hướng dẫn bên trái và làm theo các bước bên dưới để làm rối mã nguồn:

MIT License