как скрыть код в питоне
Сокрытие в Python
Инкапсуляция – это упаковка данных в единый компонент. Сокрытие – это механизм, позволяющий ограничить доступ к данным вне какой-то области. Это немного разные принципы, хотя обычно о них говорят как об одном: мы что-то упаковали в класс, а потом сокрыли от нежелательного доступа из-вне. Можете козырнуть где-нибудь на собеседовании.
Скрывать от доступа из-вне имеет смысл, когда в вашем классе есть данные только для внутреннего использования, и вам нужно защитить от их изменения (будь-то случайного или преднамеренного) из других участков кода.
В Python мы вроде бы доверяем друг другу, и все члены класса по-умолчанию доступны из-вне. Остается лишь соглашение о том, что кто-то их не будет трогать без необходимости.
Никаких вам private/protected.
Ладно, разработчики договорились, что если добавляем подчеркивание перед именем переменной или функции, то она становится как-бы приватной, только для внутренного использования классом. «Как-бы» потому что вы запросто по-прежнему можете менять ее.
Максимум, что вам грозит – недовольство со стороны вашей IDE и коллег на code-review.
Давайте добавим два знака подчеркивания перед именем. Будем более убедительными. Может, это немного контр-интуитивно, но этот трюк сработает. Такой атрибут останется видим внутри определения класса, но как-бы «пропадет» из видимости снаружи класса:
Попытались обмануть, даже что-то там присвоили, но не нанесли урона классу! Но я знаю колдунство посильнее:
Python не смог окончательно спрятать атрибут.
Работает это так: если имя атрибута начинается с двух подчеркиваний, то Python автоматически переименует его по шаблону _ИмяКласса__ИмяАтрибута. Но! Внутри класса он будет доступен по старому имени: __ИмяАтрибута.
Эта смешная игра в прятки в действительности имеет смысл. От злонамеренного изменения мы не сможем защититься таким образом, а от случайного – да. Вообразим ситуацию с наследованием:
В производном классе мы можем и не знать, что в нашем базовом есть переменная с таким же именем, но при совпадении – мы не нарушим работы базового класса, так как внутри это будут переменные с именами _Base__x и _Derived__x.
Тот же эффект будет и с методами, и с переменными на уровне класса (а не экземпляра).
__setattr__
В одном из примеров мы умудрились установить классу атрибут, которого изначально не было в нем. Если такое поведение нежелательно, то можно определить магический метод __setattr__, который будет проверять, какой атрибут мы хотим установить и кидать исключение, если кто-то хочет записать в класс то, что мы не хотим у себя видеть.
Но сразу скажу, обычно такую защиту никто не делает. Давайте без фанатизма…
Ограничение экспорта из модулей
Еще один механизм сокрытия – сокрытие сущностей (классов, функций и т. п.) на уровне модулей от бездумного импорта.
Напишем модуль. То есть создаем папку с именем testpack, туда кладем файл __init__.py
Пишем код в __init__.py:
Далее в другом файле (из основной директории) мы попытаемся импортировать (все – *) из модуля testpack.
Имя foo было импортировано, так как мы упомянули его в переменной __all__, а bar – нет. Эта все та же защита от дурака, потому что если мы намеренно импортируем bar – ни ошибок, ни предупреждений не последует.
Еще одно замечание: если имя переменной (класса, функции) начинается с подчеркивания, то оно так же не будет импортировано при import *, даже если мы не применяем __all__. И как всегда, вы можете импортировать его вручную.
Об одном способе защиты исходников 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:
И более интересный пример, в котором производятся некоторые вычисления. Здесь все импорты и вызовы функций из зашифрованных модулей скрыты в бинарном модуле. Скачать архив можно по ссылке.
Скрытие логина и пароля в коде Python
Каким образом можно зашифровать логин с паролем в самом коде? Ну или каким-либо другим способом сделать так, чтобы нельзя было бы их получить другим людям, так как сам код должен быть открытым и доступным для просмотра другими людьми.
Есть ли смысл использования в данном случае шифра Цезаря, как в данном вопросе?
4 ответа 4
Шифр Цезаря быстренько вскроет любой сообразительный студент вроде меня.
Мухи отдельно, котлеты отдельно: просто не пишите пароль внутри кода, и проблема будет решена сама собой. Кроме того, для подключения к какой-нибудь другой базе данных не нужно будет редактировать код, что повышает удобство. А вот где тогда писать пароль — тут уже много вариантов.
Переменная окружения
В любой «взрослой» ОС есть некие глобальные переменные, именуемые переменными окружения (переменные среды, environment variables). Можно положить пароль туда, а в питоне читать эти переменные. Как менять переменные окружения, зависит от конкретной ОС (можно детали в Википедии почитать), а в коде Python их чтение может выглядеть как-нибудь так:
Простой текстовый файл
Суть проста: пишем пароль в любом текстовом редакторе, сохраняем в текстовый файл, а потом читаем этот файл в питоне.
Немного пояснений, почему я читаю файлы именно так:
правила хорошего тона предписывают явно закрывать открытые файлы после их использования. Это очень удобно делать с помощью конструкции with ;
Полноценный файл конфигурации
Высока вероятность, что вы захотите хранить отдельно от кода не только логин и пароль, так почему бы не завести полноценный конфиг? Можно создать, к примеру, такой файл config.ini :
А потом распарсить его в питоне:
ConfigParser — очень мощная и универсальная штука; рекомендую почитать документацию хотя бы для общего развития.
Python-модуль с переменными
И потом обращаться к ним после импорта:
Так как local_settings.py является полноценным Python-файлом, там можно выполнять какой-нибудь произвольный код, что увеличивает гибкость в сравнении с текстовыми файлами, но в то же время открывает новые способы для выстрела в ногу, так что аккуратно.
Кстати, все связанные с файлами способы можно комбинировать с переменными окружения. Суть такова: в переменной окружения прописываем, что читать, а Python-код потом читает указанный там файл (или импортирует указанный модуль):
Вообще не хранить ничего и запрашивать в консоли каждый раз
Вбивать пароль от базы данных каждый раз не очень удобно, но всё же тоже вариант. При этом с использованием getpass вводимый текст в консоли не отображается (даже звёздочек нету), так что никто не узнает, какой пароль вы там вводите.
Как защитить исходный код Python?
Помощь в написании контрольных, курсовых и дипломных работ здесь.
Защитить исходный код странички ASP
Технология ASP.NET позволяет компиллировать странички *.ASP (Слышал, что получается *.ASPX) Можно.
Перевести исходный код на Python
#include #include #include int i0, i1; double x0, sigma, h, tay.
Как узнать исходный код метода из dll через код C#?
Как узнать исходный код метода из dll через код C#? помогите, пожалуйста!! :sorry:
Как получить исходный код *.exe или отредактировать его исполняемый код?
Собственно возможно ли декомпилить его так, чтобы можно было потом обратно скомпилировать? Или.
snow78, защитить никак, можно обфусцировать код.
а какие популярные компании распространяют питоновский код, скомпилированный в exe?
Добавлено через 2 минуты
Да вот и подтверждение по ссылке выше(с хабра).»Бинарные файлы модулей *.pyc и *.pyo (байт-код) легко декомпилируются, поэтому распространять их в чистом виде нельзя (если уж мы решили не показывать исходники по-настоящему).»
Если бы они могли на 100% защитить свои программы, то не появлялись бы их пиратские копии.Есть разные пути защиты своих программ, один из них, это тот, о котором сказал Garry Galler, это держать исходник на сервере. Так чаще всего поступают с играми, которые работают в режиме онлайн. Для локальных игр используют игровые приставки, но и они по моему часто требуют подключения к интернет серверу. Есть еще один путь, это богатый сервис сопровождения через интернет, чего лишаются те, кто использует пиратские программы, что склоняет пользователей использовать лицензионные продукты. Но на все эти варианты защиты, требуется наличие большого штата разработчиков, которые работают именно на обеспечение защиты. Если Вы не работаете в большой мощной фирме, то сомневаюсь, что Вы сможете заработать на продукте, который разработали в одиночку (если он даже будет пользоваться спросом), пытаясь организовать массовую продажу. Просто продукт, если он будет пользоваться спросом, разойдется без Вашего участия. Заработать программированием Вы можете только выполняя уникальные заказы, как на свою компанию, так и на стороне.
Ну или если Вы собрав талантливых единомышленников создадите революционный продукт, который постоянно будет совершенствоваться, так что пираты просто не будут успевать за Вами взламывать программы, что бы пиратские программы безнадежно устаревали. Или Ваша программа, что бы быть актуальной, должна постоянно обновлять информацию. Как например библиотеки у Касперского, или программы 1С, которые постоянно отслеживают все законодательные изменения и так далее.
Добавлено через 18 минут
snow78, Кстати, я читал про проект, разрабатываемый компанией Касперского. Если они от него не отказались, то это пожалуй самый перспективный способ защиты. Они планировали создать макеты, включая операционные системы, что бы потом для каждого заказчика из макета быстро создавать уникальный код, с которым не смогут разобраться хакеры, так как на этот код не будет универсального исходника. Для разных заказчиков будут, даже одни и те же задачи, реализованы с помощью разных кодов, включая индивидуальные ОС. Не знаю, получается у них реализовать эту задумку или нет, но идея очень мощная. Правда и реализовать такую идею может только большой мощный коллектив талантливых разработчиков.
Как эффективно запутать код Python?
Я ищу, как скрыть мой исходный код Python.
Как я могу кодировать этот пример, чтобы он не читался человеком? Мне сказали использовать base64, но я не уверен, как.
Это только ограниченное решение обфускации первого уровня, но оно встроено: в Python есть компилятор для байт-кода:
PS: “ограниченный” уровень запутывания, который вы получаете, таков, что можно восстановить код (с некоторыми именами переменных, но без комментариев и строк документации). Смотрите первый комментарий, как это сделать. Однако в некоторых случаях этот уровень запутывания может считаться достаточным.
чтобы он не читался человеком?
i означает, что все файлы закодированы!! когда вы его открываете, вы ничего не можете понять. что я хочу
Как максимум, вы можете скомпилировать источники в байт-код, а затем распространять только байт-код. Но даже это обратимо. Байткод может быть декомпилирован в получитаемые источники.
Base64 тривиально декодировать для всех, поэтому он не может служить реальной защитой и будет скрывать источники только от полных неграмотных ПК. Более того, если вы планируете фактически запустить этот код любым способом, вам нужно будет включить декодер прямо в script (или другой script в вашем дистрибутиве, который должен был запускаться законным пользователем), и это немедленно отмените кодирование/шифрование.
Методы обфускации обычно включают в себя удаление комментариев/документов, манипулирование именами, вставку кода мусора и т.д., поэтому даже если вы декомпилируете байт-код, вы получаете не очень читаемые источники. Но они все равно будут источниками Python, и Python не способен стать нечитаемым беспорядком.
Вы можете использовать base64 module для кодирования строк для остановки плечо серфинга, но это не остановит кого-то, кто найдет ваш код, если у них будет доступ к вашим файлам.
Затем вы можете использовать функцию compile() и eval() функция, чтобы выполнить свой код после его декодирования.
Итак, если у вас есть 30 строк кода, вы, вероятно, захотите зашифровать его, сделав что-то вроде этого:
Вы можете встроить свой код и скомпилировать/запустить из программы на C/C++.
Встраивание Python в другое приложение
embedded.c
В сентос, редхат, федора
hello_world.py:
запустить скрипт Python
Если вам нужна дополнительная безопасность, вы можете использовать base64 в своем коде
создайте строку base 64 вашего кода
embedded_base64.c
Хорошо, если вы хотите сделать полуобфускированный код, вы делаете код, подобный этому:
и создайте такой файл (используя приведенный выше код):
Одна хитрость заключается в том, чтобы сделать код сложным для чтения при разработке: никогда не документируйте ничего, если нужно, просто дайте вывод функции, а не то, как она работает. Сделайте имена переменных очень широкими, ссылками на фильмы или противоположными примерами: где btmnsfavclr = 16777215 где “ btmnsfavclr ” означает “Любимый цвет Бэтмена”, а значение – 16777215 или десятичная форма “ ffffff ” или белый. Не забывайте смешивать разные стили именования, чтобы сохранить этих противных людей в вашем коде. Также используйте советы на этом сайте: Топ 11 советов по разработке не поддерживаемого кода.
Может быть, вы можете примерить пиконкрет
шифровать и дешифровать библиотекой OpenAES
использование
Полное шифрование
удалить *.py *.pyc или скопировать *.pye в другую папку
Частично зашифрован (pyconcrete как lib)
скачать исходный код pyconcrete и установить с помощью setup.py
импортировать pyconcrete в ваш основной скрипт
план проекта рекомендации
Реальность заключается в том, что Python не подходит для использования, если вы хотите запутать код. В этой публикации есть отличные обсуждения по этому поводу.
Я бы маскировал код следующим образом:
закодированные:
Возможно, вам следует использовать что-то простое, например truecrypt volume для хранения исходного кода, так как это, похоже, является вашей заботой. Вы можете создать зашифрованный файл на USB-ключе или просто зашифровать весь том (при условии, что код подойдет), чтобы вы могли просто взять ключ с собой в конце дня.
Для компиляции вы можете использовать что-то вроде PyInstaller или py2exe, чтобы создать автономный исполняемый файл. Если вы действительно хотите пройти лишнюю милю, загляните в упаковщик или утилиту сжатия, чтобы добавить больше запутывания. Если ни одна из этих опций не является опцией, вы можете по крайней мере скомпилировать скрипт в байт-код, чтобы он не сразу читался. Имейте в виду, что эти методы просто замедляют попытки отладки или декомпиляции вашей программы.
Недавно я наткнулся на этот пост: Обфускация исходного кода Python с использованием AST, где автор рассказывает об обфускации исходного файла Python с помощью встроенного модуля AST. Скомпилированный двоичный файл должен был использоваться для HitB CTF и как таковой имел строгие требования запутывания.
Поскольку вы получаете доступ к отдельным узлам AST, использование этого подхода позволяет выполнять произвольные модификации исходного файла. В зависимости от того, какие преобразования вы выполняете, результирующий двоичный файл может/не может вести себя точно так же, как и не скрытый источник.
Как утверждают другие ответы, на самом деле просто не так хорошо. Base64 можно декодировать. Байткод может быть декомпилирован. Первоначально Python был просто истолкован, и большинство интерпретируемых языков пытаются ускорить интерпретацию машины больше, чем затруднить интерпретацию человеком.
Python был сделан читаемым и доступным, а не запутанным. Языковые решения о том, как код должен быть отформатирован, должны были повысить удобочитаемость для разных авторов.
Obfuscating код python просто не привязан к языку. Переоцените свои причины для запутывания кода.
Теперь есть pyminifier пакет, который может быть полезен. Он запутывает, минимизирует и сжимает код Python.
Это (как было опубликовано ранее) почти полностью бесполезно, но если вы действительно этого хотите, вы можете использовать альтернативную кодировку, например, ROT13.
Есть 2 способа запутать скрипты Python
Запутывать скрипты Python
Скомпилировать исходный файл python в объект кода
Повторите объект кода, оберните байт-код каждого объекта кода следующим форматом
Сериализация объекта кода и его запутывание
Создайте сценарий оболочки “xxx.py”, $ обозначает строковую константу, сгенерированную на предыдущем шаге.
Запускать или импортировать запутанные скрипты Python
Когда вы импортируете или запускаете этот скрипт-обертку, первый оператор должен вызвать CFunction:
Эта функция принимает 2 параметра: имя модуля и запутанный код, затем
Запустить или импортировать запутанный байт-код
После импорта модуля, когда вызывается любой объект кода в этом модуле
в первый раз из упакованного байт-кода, описанного в предыдущем разделе, мы
знать
Первая операция JUMP_ABSOLUTE переходит к смещению n
При смещении n инструкция должна вызвать функцию PyCFunction. Эта функция
восстановит запутанный байт-код между смещением 3 и n, и
поместите оригинальный байт-код со смещением 0
После вызова функции последняя инструкция возвращается к
смещение 0. Реальный байт-код теперь выполняется
Cython
Похоже, что goto ответит за это Cython. Я действительно удивлен, что никто еще не упомянул это? Вот домашняя страница: https://cython.org
В двух словах, это превращает ваш питон в C и компилирует его, таким образом делая его так же хорошо защищенным, как любая “обычная” скомпилированная распространяемая C-программа.
Хотя есть ограничения. Я не изучал их подробно сам, потому что, когда я начал читать о них, я отбросил идею для своих собственных целей. Но это все еще может работать для вас. По сути, вы не можете использовать Python в полной мере, с динамической удивительностью, которую он предлагает. Одна из главных проблем, которая возникла у меня, заключалась в том, что параметры ключевых слов нельзя использовать 🙁 Вы должны писать вызовы функций, используя только позиционные параметры. Я не подтвердил это, но я сомневаюсь, что вы можете использовать условный импорт или evals. не уверен, как полиморфизм обрабатывается…
В любом случае, если вы не пытаетесь запутать огромную базу кода после факта, или в идеале, если у вас есть намерение использовать Cython для начала, это очень заметный вариант.
Opy запутает ваш обширный, реальный, многомодульный исходный код Python бесплатно! И ВЫ выбираете для каждого проекта, что скрывать, а что нет, редактируя файл конфигурации:
По общему признанию, я все еще оцениваю это сам, но все начальные тесты этого работали отлично. Похоже, это именно то, что я искал!
Официальная версия запускается как отдельная утилита, с первоначальным заданием, согласно которому вы помещаете скрипт в корень каталога, который вы хотите скрыть, вместе с файлом конфигурации, чтобы определить детали/опции, которые вы хотите использовать. Я не был влюблен в этот план, поэтому я добавил ответвление от проекта, позволяющее вам импортировать и использовать инструмент из библиотеки. Таким образом, вы можете свернуть это непосредственно в более полный пакетный скрипт. (Конечно, вы можете обернуть несколько сценариев py в bash/batch, но я думаю, что чисто Python-решение идеально). Я попросил, чтобы мой форк был объединен с оригинальной работой, но в случае, если этого не произойдет, вот URL моей исправленной версии:
Попробуйте этот питон-обфускатор:
будет переведен на
Requirements
cp Python.h tcc\include
Я напишу свой ответ дидактически…
Первый тип в интерпретаторе Python:
тогда идите и посмотрите файл this.py в вашем каталоге Lib в вашем дистрибутиве Python и попытайтесь понять, что он делает.
После этого взгляните на функцию eval в документации:
Теперь вы должны найти забавный способ защитить свой код. Но будьте осторожны, потому что это работает только для людей, которые менее умны, чем вы! (и я не пытаюсь быть оскорбительным, любой разумный, чтобы понять, что вы сделали, может изменить его).
Существует несколько способов обфускации кода. Вот только один пример:
Попробуйте вставить свой код кода hello world python на следующий сайт:
Он создаст сложный зашифрованный и запутанный, но полностью функциональный script для вас. Посмотрите, можете ли вы взломать script и показать фактический код. Или посмотрите, удовлетворяет ли уровень сложности, который вам нужен, для спокойствия.
Зашифрованный script, который создается для вас через этот сайт, должен работать в любой системе Unix, на которой установлен python.
Если вы хотите зашифровать другой способ, я настоятельно рекомендую вам написать собственный алгоритм шифрования/обфускации (если безопасность важна для вас). Таким образом, никто не может понять, как это работает, но вы. Но для того, чтобы это действительно работало, вы должны потратить на это огромное количество времени, чтобы не было никаких лазеек, которые могут использовать те, у кого есть много времени на их руках. И убедитесь, что вы используете инструменты, которые уже являются естественными для системы Unix… т.е. Openssl или base64. Таким образом, ваш зашифрованный script более портативный.