Подтвердить что ты не робот

Как эффективно запутать код Python?

Я ищу, как скрыть мой исходный код Python.

print "Hello World!"

Как я могу кодировать этот пример, чтобы он не читался человеком? Мне сказали использовать base64, но я не уверен, как.

4b9b3361

ОТВЕТЫ

Ответ 1

Это только ограниченное решение обфускации первого уровня, но оно встроено: в Python есть компилятор для байт-кода:

python -OO -m py_compile <your program.py>

создает файл .pyo, содержащий байт-код, где удаляются строки документации и т.д. Вы можете переименовать файл .pyo с расширением .py, и python <your program.py> работает как ваша программа, но не содержит ваш исходный код код.

PS: "ограниченный" уровень запутывания, который вы получаете, таков, что можно восстановить код (с некоторыми именами переменных, но без комментариев и строк документации). Смотрите первый комментарий, как это сделать. Однако в некоторых случаях этот уровень запутывания может считаться достаточным.

PPS: Если ваша программа импортирует модули, запутанные таким образом, то вам нужно вместо этого переименовать их с суффиксом .pyc (я не уверен, что это однажды не сломается), или вы можете работать с .pyo и запускать их с python -O ….pyo (импорт должен работать). Это позволит Python найти ваши модули (в противном случае Python ищет модули .py).

Ответ 2

чтобы он не читался человеком?

i означает, что все файлы закодированы!! когда вы его открываете, вы ничего не можете понять..! что я хочу

Как максимум, вы можете скомпилировать источники в байт-код, а затем распространять только байт-код. Но даже это обратимо. Байткод может быть декомпилирован в получитаемые источники.

Base64 тривиально декодировать для всех, поэтому он не может служить реальной защитой и будет скрывать источники только от полных неграмотных ПК. Более того, если вы планируете фактически запустить этот код любым способом, вам нужно будет включить декодер прямо в script (или другой script в вашем дистрибутиве, который должен был запускаться законным пользователем), и это немедленно отмените кодирование/шифрование.

Методы обфускации обычно включают в себя удаление комментариев/документов, манипулирование именами, вставку кода мусора и т.д., поэтому даже если вы декомпилируете байт-код, вы получаете не очень читаемые источники. Но они все равно будут источниками Python, и Python не способен стать нечитаемым беспорядком.

Если вам абсолютно необходимо защитить некоторые функциональные возможности, я бы посоветовал перейти на скомпилированные языки, такие как C или С++, компилировать и распространять .so/.dll, а затем использовать привязки Python к защищенному коду.

Ответ 3

Вы можете использовать base64 module для кодирования строк для остановки плечо серфинга, но это не остановит кого-то, кто найдет ваш код, если у них будет доступ к вашим файлам.

Затем вы можете использовать функцию compile() и eval() функция, чтобы выполнить свой код после его декодирования.

>>> import base64
>>> mycode = "print 'Hello World!'"
>>> secret = base64.b64encode(mycode)
>>> secret
'cHJpbnQgJ2hlbGxvIFdvcmxkICEn'
>>> mydecode = base64.b64decode(secret)
>>> eval(compile(mydecode,'<string>','exec'))
Hello World!

Итак, если у вас есть 30 строк кода, вы, вероятно, захотите зашифровать его, сделав что-то вроде этого:

>>> f = open('myscript.py')
>>> encoded = base64.b64encode(f.read())

Затем вам понадобится написать второй script, который будет compile() и eval(), который, вероятно, будет включать кодированный script как строковый литерал, заключенный в тройные кавычки. Поэтому он выглядит примерно так:

import base64
myscript = """IyBUaGlzIGlzIGEgc2FtcGxlIFB5d
              GhvbiBzY3JpcHQKcHJpbnQgIkhlbG
              xvIiwKcHJpbnQgIldvcmxkISIK"""
eval(compile(base64.b64decode(myscript),'<string>','exec'))

Ответ 4

Вы можете встроить свой код и скомпилировать/запустить из программы на C/C++. Встраивание Python в другое приложение

embedded.c

#include <Python.h>

int
main(int argc, char *argv[])
{
  Py_SetProgramName(argv[0]);  /* optional but recommended */
  Py_Initialize();
  PyRun_SimpleString("print('Hello world !')");
  Py_Finalize();
  return 0;
}

В Ubuntu Debian

$ sudo apt-get install python-dev

В сентос, редхат, федора

$ sudo yum install python-devel

компилировать с

$ gcc -o embedded -fPIC -I/usr/include/python2.7 -lpython2.7 embedded.c

работать с

$ chmod u+x ./embedded
$ time ./embedded
Hello world !

real  0m0.014s
user  0m0.008s
sys 0m0.004s

hello_world.py:

print('Hello World !')

запустить скрипт Python

$ time python hello_world.py
Hello World !

real  0m0.014s
user  0m0.008s
sys 0m0.004s

тем не менее, некоторые строки кода Python могут быть найдены в скомпилированном файле .c

$ grep "Hello" ./embedded
Binary file ./embedded matches

$ grep "Hello World" ./embedded
$

Если вам нужна дополнительная безопасность, вы можете использовать base64 в своем коде

...
PyRun_SimpleString("import base64\n"
                  "base64_code = 'your python code in base64'\n"
                  "code = base64.b64decode(base64_code)\n"
                  "exec(code)");
...

например:

создайте строку base 64 вашего кода

$ base64 hello_world.py
cHJpbnQoJ0hlbGxvIFdvcmxkICEnKQoK

embedded_base64.c

#include <Python.h>

int
main(int argc, char *argv[])
{
  Py_SetProgramName(argv[0]);  /* optional but recommended */
  Py_Initialize();
  PyRun_SimpleString("import base64\n"
                    "base64_code = 'cHJpbnQoJ0hlbGxvIFdvcmxkICEnKQoK'\n"
                    "code = base64.b64decode(base64_code)\n"
                    "exec(code)\n");
  Py_Finalize();
  return 0;
}

все команды

$ gcc -o embedded_base64 -fPIC -I/usr/include/python2.7 -lpython2.7 ./embedded_base64.c
$ chmod u+x ./embedded_base64

$ time ./embedded_base64
Hello World !

real  0m0.014s
user  0m0.008s
sys 0m0.004s

$ grep "Hello" ./embedded_base64
$

Ответ 5

Хорошо, если вы хотите сделать полуобфускированный код, вы делаете код, подобный этому:

import base64
import zlib
def run(code): exec(zlib.decompress(base64.b16decode(code)))
def enc(code): return base64.b16encode(zlib.compress(code))

и создайте такой файл (используя приведенный выше код):

f = open('something.py','w')
f.write("code=" + enc("""
print("test program")
print(raw_input("> "))"""))
f.close()

файл "thing.py ":

code = '789CE352008282A2CCBC120DA592D4E212203B3FBD28315749930B215394581E9F9957500A5463A7A0A4A90900ADFB0FF9'

просто импортируйте "thing.py "и запустите run(something.code), чтобы запустить код в файле.

Одна хитрость заключается в том, чтобы сделать код сложным для чтения при разработке: никогда не документируйте ничего, если нужно, просто дайте вывод функции, а не то, как она работает. Сделайте имена переменных очень широкими, ссылками на фильмы или противоположными примерами: где btmnsfavclr = 16777215 где "btmnsfavclr" означает "Любимый цвет Бэтмена", а значение - 16777215 или десятичная форма "ffffff" или белый. Не забывайте смешивать разные стили именования, чтобы сохранить этих противных людей в вашем коде. Также используйте советы на этом сайте: Топ 11 советов по разработке не поддерживаемого кода.

Ответ 6

Может быть, вы можете примерить пиконкрет

зашифровать .pyc в .pye и расшифровать при импорте

шифровать и дешифровать библиотекой OpenAES

использование

Полное шифрование

  • конвертировать все ваши .py в *.pye

    $ pyconcrete-admin.py compile --source={your py script}  --pye
$ pyconcrete-admin.py compile --source={your py module dir} --pye

  • удалить *.py *.pyc или скопировать *.pye в другую папку

  • main.py зашифрован как main.pye, он не может быть выполнен обычным python. Вы должны использовать pyconcrete для обработки сценария main.pye. pyconcrete (exe) будет установлен в вашем системном пути (например: /usr/local/bin)

    pyconcrete main.pye
src/*.pye  # your libs

Частично зашифрован (pyconcrete как lib)

  • скачать исходный код pyconcrete и установить с помощью setup.py

    $ python setup.py install \
  --install-lib={your project path} \
  --install-scripts={where you want to execute pyconcrete-admin.py and pyconcrete(exe)}

  • импортировать pyconcrete в ваш основной скрипт

  • план проекта рекомендации

    main.py       # import pyconcrete and your lib
pyconcrete/*  # put pyconcrete lib in project root, keep it as original files
src/*.pye     # your libs

Ответ 7

Реальность заключается в том, что Python не подходит для использования, если вы хотите запутать код. В этой публикации есть отличные обсуждения по этому поводу.

Ответ 8

Я бы маскировал код следующим образом:

def MakeSC():
    c = raw_input(" Encode: ")
    sc = "\\x" + "\\x".join("{0:x}".format(ord(c)) for c in c)
    print "\n shellcode =('" + sc + "'); exec(shellcode)"; MakeSC();

Аут:

import os; os.system("whoami")

закодированные:

Payload = ('\x69\x6d\x70\x6f\x72\x74\x20\x6f\x73\x3b\x20\x6f\x73\x2e\x73\x79\x73\x74\x65\x6d\x28\x22\x77\x68\x6f\x61\x6d\x69\x22\x29'); exec(Payload);

Ответ 9

Возможно, вам следует использовать что-то простое, например truecrypt volume для хранения исходного кода, так как это, похоже, является вашей заботой. Вы можете создать зашифрованный файл на USB-ключе или просто зашифровать весь том (при условии, что код подойдет), чтобы вы могли просто взять ключ с собой в конце дня.

Для компиляции вы можете использовать что-то вроде PyInstaller или py2exe, чтобы создать автономный исполняемый файл. Если вы действительно хотите пройти лишнюю милю, загляните в упаковщик или утилиту сжатия, чтобы добавить больше запутывания. Если ни одна из этих опций не является опцией, вы можете по крайней мере скомпилировать скрипт в байт-код, чтобы он не сразу читался. Имейте в виду, что эти методы просто замедляют попытки отладки или декомпиляции вашей программы.

Ответ 10

Недавно я наткнулся на этот пост: Обфускация исходного кода Python с использованием AST, где автор рассказывает об обфускации исходного файла Python с помощью встроенного модуля AST. Скомпилированный двоичный файл должен был использоваться для HitB CTF и как таковой имел строгие требования запутывания.

Поскольку вы получаете доступ к отдельным узлам AST, использование этого подхода позволяет выполнять произвольные модификации исходного файла. В зависимости от того, какие преобразования вы выполняете, результирующий двоичный файл может/не может вести себя точно так же, как и не скрытый источник.

Ответ 11

Как утверждают другие ответы, на самом деле просто не так хорошо. Base64 можно декодировать. Байткод может быть декомпилирован. Первоначально Python был просто истолкован, и большинство интерпретируемых языков пытаются ускорить интерпретацию машины больше, чем затруднить интерпретацию человеком.

Python был сделан читаемым и доступным, а не запутанным. Языковые решения о том, как код должен быть отформатирован, должны были повысить удобочитаемость для разных авторов.

Obfuscating код python просто не привязан к языку. Переоцените свои причины для запутывания кода.

Ответ 12

Теперь есть pyminifier пакет, который может быть полезен. Он запутывает, минимизирует и сжимает код Python.

Ответ 13

Это (как было опубликовано ранее) почти полностью бесполезно, но если вы действительно этого хотите, вы можете использовать альтернативную кодировку, например, ROT13.

Ответ 14

Есть 2 способа запутать скрипты Python

  • Запутывать байтовый код каждого объекта кода
  • Запутать весь объект кода модуля Python

Запутывать скрипты Python

  • Скомпилировать исходный файл python в объект кода

    char * filename = "xxx.py";
char * source = read_file( filename );
PyObject *co = Py_CompileString( source, filename, Py_file_input );

  • Повторите объект кода, оберните байт-код каждого объекта кода следующим форматом

    0   JUMP_ABSOLUTE            n = 3 + len(bytecode)    
3
...
... Here it obfuscated bytecode
...

n   LOAD_GLOBAL              ? (__armor__)
n+3 CALL_FUNCTION            0
n+6 POP_TOP
n+7 JUMP_ABSOLUTE            0

  • Сериализация объекта кода и его запутывание

    char *original_code = marshal.dumps( co );
char *obfuscated_code = obfuscate_algorithm( original_code  );

  • Создайте сценарий оболочки "xxx.py", $ {obfuscated_code} обозначает строковую константу, сгенерированную на предыдущем шаге.

    __pyarmor__(__name__, b'${obfuscated_code}')

Запускать или импортировать запутанные скрипты Python

Когда вы импортируете или запускаете этот скрипт-обертку, первый оператор должен вызвать CFunction:

int __pyarmor__(char *name, unsigned char *obfuscated_code) 
{
  char *original_code = resotre_obfuscated_code( obfuscated_code );
  PyObject *co = marshal.loads( original_code );
  PyObject *mod = PyImport_ExecCodeModule( name, co );
}

Эта функция принимает 2 параметра: имя модуля и запутанный код, затем

  • Восстановить запутанный код
  • Создать объект кода по оригинальному коду
  • Импортировать оригинальный модуль (это приведет к дублированию кадра в Traceback)

Запустить или импортировать запутанный байт-код

После импорта модуля, когда вызывается любой объект кода в этом модуле в первый раз из упакованного байт-кода, описанного в предыдущем разделе, мы знать

  • Первая операция JUMP_ABSOLUTE переходит к смещению n

  • При смещении n инструкция должна вызвать функцию PyCFunction. Эта функция восстановит запутанный байт-код между смещением 3 и n, и поместите оригинальный байт-код со смещением 0

  • После вызова функции последняя инструкция возвращается к смещение 0. Реальный байт-код теперь выполняется

Обратитесь к Pyarmor

Ответ 15

Cython

Похоже, что goto ответит за это Cython. Я действительно удивлен, что никто еще не упомянул это? Вот домашняя страница: https://cython.org

В двух словах, это превращает ваш питон в C и компилирует его, таким образом делая его так же хорошо защищенным, как любая "обычная" скомпилированная распространяемая C-программа.

Хотя есть ограничения. Я не изучал их подробно сам, потому что, когда я начал читать о них, я отбросил идею для своих собственных целей. Но это все еще может работать для вас. По сути, вы не можете использовать Python в полной мере, с динамической удивительностью, которую он предлагает. Одна из главных проблем, которая возникла у меня, заключалась в том, что параметры ключевых слов нельзя использовать :( Вы должны писать вызовы функций, используя только позиционные параметры. Я не подтвердил это, но я сомневаюсь, что вы можете использовать условный импорт или evals. не уверен, как полиморфизм обрабатывается...

В любом случае, если вы не пытаетесь запутать огромную базу кода после факта, или в идеале, если у вас есть намерение использовать Cython для начала, это очень заметный вариант.

Ответ 16

OpY

https://github.com/QQuick/Opy

Opy запутает ваш обширный, реальный, многомодульный исходный код Python бесплатно! И ВЫ выбираете для каждого проекта, что скрывать, а что нет, редактируя файл конфигурации:

You can recursively exclude all identifiers of certain modules from obfuscation.
You can exclude human readable configuration files containing Python code.
You can use getattr, setattr, exec and eval by excluding the identifiers they use.
You can even obfuscate module file names and string literals.
You can run your obfuscated code from any platform.

В отличие от некоторых других опций, опубликованных, это работает как для Python 2, так и для 3 ! Это также бесплатно/с открытым исходным кодом, и это не только онлайн-инструмент (если вы не платите), как некоторые другие там.

По общему признанию, я все еще оцениваю это сам, но все начальные тесты этого работали отлично. Похоже, это именно то, что я искал!

Официальная версия запускается как отдельная утилита, с первоначальным заданием, согласно которому вы помещаете скрипт в корень каталога, который вы хотите скрыть, вместе с файлом конфигурации, чтобы определить детали/опции, которые вы хотите использовать. Я не был влюблен в этот план, поэтому я добавил ответвление от проекта, позволяющее вам импортировать и использовать инструмент из библиотеки. Таким образом, вы можете свернуть это непосредственно в более полный пакетный скрипт. (Конечно, вы можете обернуть несколько сценариев py в bash/batch, но я думаю, что чисто Python-решение идеально). Я попросил, чтобы мой форк был объединен с оригинальной работой, но в случае, если этого не произойдет, вот URL моей исправленной версии:

https://github.com/BuvinJT/Opy

Ответ 17

Попробуйте этот питон-обфускатор:

pyob.oxyry.com pyob.oxyry.c

__all__ = ['foo']

a = 'a'
_b = 'b'

def foo():
    print(a)

def bar():
    print(_b)

def _baz():
    print(a + _b)

foo()
bar()
_baz()

будет переведен на

__all__ =['foo']#line:1
OO00OO0OO0O00O0OO ='a'#line:3
_O00OO0000OO0O0O0O ='b'#line:4
def foo ():#line:6
    print (OO00OO0OO0O00O0OO )#line:7
def O0000000OOOO00OO0 ():#line:9
    print (_O00OO0000OO0O0O0O )#line:10
def _OOO00000O000O0OOO ():#line:12
    print (OO00OO0OO0O00O0OO +_O00OO0000OO0O0O0O )#line:13
foo ()#line:15
O0000000OOOO00OO0 ()#line:16
_OOO00000O000O0OOO ()#line:17

Ответ 18

  Лучший способ сделать это - сначала сгенерировать файл .c, а затем скомпилировать его с tcc в файл .pyd
Примечание: только для Windows

Requirements

  1. TCC
  2. pyobfuscate
  3. Cython

Установка:

sudo pip install -U cython

Чтобы скрыть файл .py:

pyobfuscate.py myfile.py >obfuscated.py

Чтобы создать файл .c,

  1. Добавьте функцию init<filename>() в ваш файл .py Необязательно

  2. cython --embed file.py

  3. cp Python.h tcc\include

  4. tcc file.c -o file.pyd -shared -I\path\to\Python\include -L\path\to\Python\lib

  5. импортировать файл .pyd в app.exe

Ответ 19

Я напишу свой ответ дидактически...

Первый тип в интерпретаторе Python:

import this

тогда идите и посмотрите файл this.py в вашем каталоге Lib в вашем дистрибутиве Python и попытайтесь понять, что он делает.

После этого взгляните на функцию eval в документации:

help(eval)

Теперь вы должны найти забавный способ защитить свой код. Но будьте осторожны, потому что это работает только для людей, которые менее умны, чем вы! (и я не пытаюсь быть оскорбительным, любой разумный, чтобы понять, что вы сделали, может изменить его).

Ответ 20

Существует несколько способов обфускации кода. Вот только один пример:

(lambda _, __, ___, ____, _____, ______, _______, ________:
    getattr(
        __import__(True.__class__.__name__[_] + [].__class__.__name__[__]),
        ().__class__.__eq__.__class__.__name__[:__] +
        ().__iter__().__class__.__name__[_____:________]
    )(
        _, (lambda _, __, ___: _(_, __, ___))(
            lambda _, __, ___:
                chr(___ % __) + _(_, __, ___ // __) if ___ else
                (lambda: _).func_code.co_lnotab,
            _ << ________,
            (((_____ << ____) + _) << ((___ << _____) - ___)) + (((((___ << __)
            - _) << ___) + _) << ((_____ << ____) + (_ << _))) + (((_______ <<
            __) - _) << (((((_ << ___) + _)) << ___) + (_ << _))) + (((_______
            << ___) + _) << ((_ << ______) + _)) + (((_______ << ____) - _) <<
            ((_______ << ___))) + (((_ << ____) - _) << ((((___ << __) + _) <<
            __) - _)) - (_______ << ((((___ << __) - _) << __) + _)) + (_______
            << (((((_ << ___) + _)) << __))) - ((((((_ << ___) + _)) << __) +
            _) << ((((___ << __) + _) << _))) + (((_______ << __) - _) <<
            (((((_ << ___) + _)) << _))) + (((___ << ___) + _) << ((_____ <<
            _))) + (_____ << ______) + (_ << ___)
        )
    )
)(
    *(lambda _, __, ___: _(_, __, ___))(
        (lambda _, __, ___:
            [__(___[(lambda: _).func_code.co_nlocals])] +
            _(_, __, ___[(lambda _: _).func_code.co_nlocals:]) if ___ else []
        ),
        lambda _: _.func_code.co_argcount,
        (
            lambda _: _,
            lambda _, __: _,
            lambda _, __, ___: _,
            lambda _, __, ___, ____: _,
            lambda _, __, ___, ____, _____: _,
            lambda _, __, ___, ____, _____, ______: _,
            lambda _, __, ___, ____, _____, ______, _______: _,
            lambda _, __, ___, ____, _____, ______, _______, ________: _
        )
    )
)

Ответ 21

Попробуйте вставить свой код кода hello world python на следующий сайт:

http://enscryption.com/encrypt-and-obfuscate-scripts.html

Он создаст сложный зашифрованный и запутанный, но полностью функциональный script для вас. Посмотрите, можете ли вы взломать script и показать фактический код. Или посмотрите, удовлетворяет ли уровень сложности, который вам нужен, для спокойствия.

Зашифрованный script, который создается для вас через этот сайт, должен работать в любой системе Unix, на которой установлен python.

Если вы хотите зашифровать другой способ, я настоятельно рекомендую вам написать собственный алгоритм шифрования/обфускации (если безопасность важна для вас). Таким образом, никто не может понять, как это работает, но вы. Но для того, чтобы это действительно работало, вы должны потратить на это огромное количество времени, чтобы не было никаких лазеек, которые могут использовать те, у кого есть много времени на их руках. И убедитесь, что вы используете инструменты, которые уже являются естественными для системы Unix... т.е. Openssl или base64. Таким образом, ваш зашифрованный script более портативный.