как обфусцировать код python

Обфускация кода Python?

37 str1k3r [2010-07-27 16:29:00]

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

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

21 ответ

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

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

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

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

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

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

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

21 Dave Webb [2010-07-27 16:39:00]

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

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

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

9 xyz [2016-09-05 00:33:00]

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

embedded.c

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

hello_world.py:

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

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

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

embedded_base64.c

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

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

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

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

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

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

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

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

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

Ну, если вы хотите сделать полуобфузированный код, вы создадите код следующим образом:

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

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

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

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

7 Isaac [2013-08-09 19:46:00]

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

4 7h3rAm [2013-09-04 07:33:00]

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

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

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

3 krs1 [2010-07-27 19:17:00]

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

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

2 Weijar Z [2018-04-18 11:55:00]

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

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

2 Broam [2010-07-27 17:32:00]

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

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

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

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

1 BuvinJ [2018-10-15 17:26:00]

Cython

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

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

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

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

1 BuvinJ [2018-10-16 15:38:00]

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

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

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

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

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

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

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

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

Создайте скрипт-обертку «xxx.py», $ обозначает строковую константу, сгенерированную на предыдущем шаге.

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

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

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

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

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

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

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

2. Выполните команду ниже на cmd, заменив параметры

3. Теперь скачайте tcc.
4. Копирование Python включает в себя TCC включает.
Выполните команду, показанную ниже

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

0 RoyMWell [2017-03-31 19:09:00]

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

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

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

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

0 fortran [2010-07-27 19:35:00]

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

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

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

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

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

Источник

Запутывать код Python?

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

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

17 ответов

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

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

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

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

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

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

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

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

Ну, если вы хотите сделать полуобфускированный код, вы делаете код, подобный следующему:

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

Источник

Как обфусцировать код python

Python Code Obfuscator

I was browsing /r/dailyprogrammer on Reddit one day, and attempted one of the daily challenges. After doing the challenge, I read through the comments and found a very interesting submission.

Seeing that baffled me at first sight, but after reading /u/ntxhhf’s breakdown of his code, I was inspired to make my own code obfuscator for Python using the ideas in his post.

What exactly does this script do?
It takes your regular-looking Python code, and obfuscates it! It takes any specified Python script, and will attempt to create an equivalent script that has the same exact functionality as the original, but is incredibly difficult for humans to read regularly.

So. how is this useful?
According to Wikipedia.

Programmers may deliberately obfuscate code to conceal its purpose (security through obscurity) or its logic or implicit values embedded in it, primarily, in order to prevent tampering, deter reverse engineering, or even as a puzzle or recreational challenge for someone reading the source code.

Masking Numerical Values

Input: Using Netwon’s Method to find the square root of 17

Output:

There are two ways the parser can encrypt strings. The first way is with hex strings, and the other using the number encoding method above.

Example Input: print(«Hello World!»)

Output

Hiding Calls to Python’s Built-In Functions

In Python, we can call a built-in function indirectly: getattr(__import__(‘builtins’), ‘abs’)(5)
So to call a function, we just use the string-encoding method detailed above. It’s definitely not space-efficient, but it works!

Input: print(chr(65))

Output:

About

Transform regular Python code into a human-averse, yet still-functional equivalent.

Источник

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

Исследование методов запутывания python

Эй, я Дэвид, и сегодня я хотел бы поговорить о различных методах, которые вы можете использовать для запутывания кода python. Запутывание-невероятно сложная и удивительная тема, и я надеюсь, что она вам понравится.

Основы: Что такое обфускация

Формально запутывание кода определяется как преднамеренный акт создания исходного или машинного кода, который трудно понять людям. Он обычно используется, потому что автор хочет:

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

Как вы должны думать о схемах запутывания

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

Основная техника № 1: Удаление всей информации, которая бесполезна для интерпретатора/парсера

Основной способ запутать ваш код-просто переименовать все ваши именованные параметры (имена переменных, имена ключей словаря, все имена, которые имеют бессмысленную связь с данными, которые они содержат; будьте изобретательны).

Давайте взглянем на следующий код. Это простой фрагмент кода, чтобы найти медиану массива целых чисел, а также тестовый класс для указанного фрагмента кода.

Мы будем использовать этот код на протяжении всей статьи.

(кредиты на python wiki; https://wiki.python.org/moin/SimplePrograms)

Давайте переименуем все переменные в бессмысленные строки:

Это труднее читать, верно? Вы даже можете развить эту концепцию, переименовав все идентификаторы во что-то очень похожее, например, шаблон”0″и” O “или шаблон” l ” и “1”.

Основная техника № 2: Синтаксическое запутывание

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

Давайте снова возьмем наш запутанный код и убьем форматирование:

Хотя это и не большая перемена, сделать это не помешает.

Продвинутая техника № 1: Переписывание выражений

Переписывание арифметических выражений, литералов int и строковых литералов-хороший способ запутать, потому что он может скрыть истинное значение числа на первый взгляд. Это затрудняет просто grep для магических чисел, строк или выражений в целом. Например, мы можем переписать выражение ” 1 ” как ‘6+97+45-991+844*23+ 54/8/18575.75′, выражение; x’ как

а выражение “Привет, мир!” как

Приложение А

Переписывание программы в виде лямбда-выражения

Это довольно продвинутый подход, и я решил не включать его в эту статью, но почти весь код python может быть переписан как лямбда-выражение. Давайте перепишем наш пример кода:

А теперь посмотри на это! Удачи вам в этом!

Источник

Об одном способе защиты исходников Python-программы

Как всё начиналось

Однажды мне пришлось участвовать в разработке одного небольшого проекта для научных расчётов, который разрабатывался на языке программирования Python. Изначально Python был выбран как удобный и гибкий язык для экспериментов, визуализации, быстрого прототипирования и разработки алгоритмов, но в дальнейшем стал основным языком разработки проекта. Надо заметить, что проект был хоть и не большим, но довольно насыщенным технически. Для обеспечения требуемой функциональности, в проекте широко применялись алгоритмы теории графов, математическая оптимизация, линейная алгебра и статистика. Также использовались декораторы, метаклассы и инструменты интроспекции. В процессе разработки пришлось использовать сторонние математические пакеты и библиотеки, например, такие как numpy и scipy, а также многие другие.

Со временем стало ясно, что переписывать проект на компилируемом языке слишком затратно по времени и ресурсам. Скорость работы и потребление памяти не являлись критичными показателями в данном случае и были вполне приемлемыми и достаточными. Поэтому было принято решение оставить всё как есть, и продолжить разработку и поддержку проекта на языке Python. К тому же, документация по большей части уже была написана с использованием Sphinx.

Проект являлся библиотекой, функции которой использовались в одном из модулей расширения в крупном программном комплексе. Программный комплекс был написан на C++, являлся коммерческим продуктом, имел защиту с аппаратным ключом и поставлялся клиентам без предоставления исходных кодов.

Здесь сразу обозначилась новая проблема: как защитить исходные коды нашей Python-библиотеки? Может быть, в ином случае никто бы не стал этим заниматься, я бы уж точно, но в библиотеке были реализованы некоторые ноу-хау, и руководители проекта не хотели, чтобы данные наработки попали к конкурентам. Так как я был одним из исполнителей, мне пришлось озаботиться данной проблемой. Далее я постараюсь рассказать об основной идее, что из этого вышло, и как нам удалось скрыть Python-исходники от лишних глаз.

Что предлагают люди

Как известно, наверное, большинству разработчиков, Python — язык интерпретируемый, динамический с богатыми возможностями интроспекции. Бинарные файлы модулей *.pyc и *.pyo (байт-код) легко декомпилируются, поэтому распространять их в чистом виде нельзя (если уж мы решили не показывать исходники по-настоящему).

Как, я думаю, любой на моём месте, сначала я решил поискать, а что вообще делают люди в таких случаях? Первые же поисковые запросы показали, что люди не знают, что делать и спрашивают об этом на stackoverflow и в других местах, например, вот вопрос на stackoverflow. Поискав, я пришёл к выводу, что везде предлагают несколько спорных способов:

По многим причинам я отбросил все эти способы как неподходящие. Например, обфускация Python-кода. Ну какая может быть обфускация, когда синтаксис языка построен на отступах, а сам язык пронизан «хитрой интроспекцией»? Транслировать все Python-модули в бинарные модули расширения тоже не представлялось возможным, т. к. проект, напомню, был достаточно сложным технически с использованием множества сторонних пакетов, да и сам состоял из большого числа модулей в многоуровневой иерархии пакетов, которые было утомительно перегонять в *.pyd, а потом ловить баги, вылезающие на ровном месте. Возиться с заменой опкодов не хотелось, так как пришлось бы распространять и поддерживать собственную сборку интерпретатора Python, да ещё и компилировать им Python-модули всех используемых сторонних библиотек.

В какой-то момент мне показалось, что эта идея с защитой Python-исходников бесполезная, надо всё это бросить и убедить руководство, что ничего не выйдет и заняться чем-нибудь полезным. Отдаём *.pyc файлы и ладно, кто там будет разбираться? Убедить не получилось, переписывать библиотеку на C++ никому не хотелось, а проект нужно было сдавать. В итоге всё же кое-что получилось сделать. Об этом, если всё ещё интересно, можно прочитать далее.

Что сделали мы

Что может лучше всего защитить какую-либо информацию на цифровом носителе от посторонних? Я думаю, что это шифрование. Вооружившись этой фундаментальной идеей, я решил, что исходники надо шифровать, а иначе и быть не должно. Для стороннего наблюдателя, который начал проявлять излишний интерес, всё это должно выглядеть как куча непонятных файлов с непонятным содержимым. Вполне себе обфускация, но более продвинутая чем заменять имена переменных и вставлять пустые строчки.

Ход моих мыслей был следующим:

Основная идея, думаю, ясна — это более продвинутая обфускация. Как это сделать? Погуглив, я пришёл к выводу, что сделать это вполне реально и даже достаточно просто. С шифрованием исходников всё понятно, зашифровать и/или обфусцировать файлы можно множеством способов, главное, чтобы там была «каша» и «ничего не понятно», а также всё это должно возвращаться к первоначальному виду неизвестным способом (в случае обфускации). Для приведённого здесь примера я буду использовать Python-модуль base64 для «шифрования». В некритичных случаях можно применять замечательный пакет obfuscate.

Python the Importer Protocol

Итак, вроде бы добрались до сути. Можно привести простой пример. Минимальный пример класса, реализующего Importer Protocol, подходящего для наших целей. Он будет заниматься импортом модулей «зашифрованных» base64 из обычной структуры пакетов (в данном случае для простоты мы просто «зашифровали содержимое» файлов, но никак не меняли их имена и структуру пакетов). Считаем, что расширения файлов для наших модулей будут гордо называться «.b64».

Как это работает? Первым делом при создании экземпляра класса собирается информация о модулях нашей библиотеки, которую мы «шифруем». Затем при загрузке конкретного модуля, читается нужный «зашифрованный» файл, «расшифровывается» и импортируется с помощью средств модуля imp уже из «расшифрованной» текстовой строки. Как использовать данный класс? Очень легко. Буквально, одной строчкой включается возможность импортировать «зашифрованные» исходники нашей библиотеки, а по сути ставится хук на импорт:

где root_pkg_path абсолютный или относительный путь к корневому пакету нашей библиотеки. При этом, убирая данную строчку, мы можем использовать обычные исходники, если они доступны. Всё происходит абсолютно прозрачно, а все изменения происходят в одном месте.

Вот и всё, с этого момента импорт модулей из нашей библиотеки осуществляется с перехватом и «расшифровкой». Наш хук будет дёргаться при любом вызове инструкции import, и если импортируется модули нашей библиотеки, хук будет их обрабатывать и загружать, остальные импорты будут обрабатываться стандартно. Что нам и требовалось для более продвинутой обфускации. Представленный код импортёра и установки хука можно положить уже в *.pyd файл и надеяться на то, что никто не будет его дизассемблировать в надежде понять, что мы тут наворотили. В реальном проекте можно использовать настоящее шифрование, в том числе с использованием аппаратного ключа, что должно повысить надёжность данного метода. Также изменение имён файлов и структуры пакетов может быть полезным для большего запутывания.

Заключение

Возможно, что всё, что тут написано и яйца выеденного не стоит — давно известные истины, либо бред сумасшедшего. Но если вышеописанное кому-то может оказаться полезным, я буду рад. Лично для меня данный опыт был полезен, хотя бы потому, что позволил лучше разобраться в мощной и гибкой системе загрузки и импортирования модулей и Importer Protocol. О тех самых штуках, которые чаще всего не требуются разработчикам для написания программ на Python. Всегда интересно узнать что-то новое.

Спасибо за внимание.

UPD 14.08.2013:
По просьбе tangro сделал минимальный проект, в котором демонстрируется описанный способ, но без настоящего шифрования (применены только некие алгоритмы обратимого преобразования).
Скачать zip-архив можно по ссылке. Нужен Python 2.7 x86 под Windows. Запускать нужно скрипт «test_main.py».

UPD 2:
И более интересный пример, в котором производятся некоторые вычисления. Здесь все импорты и вызовы функций из зашифрованных модулей скрыты в бинарном модуле. Скачать архив можно по ссылке.

Источник