Ты как поймешь что это литерал который можно и нужно приморфить?
Constexp, возможно, и не пойму, если нужны макросы, то через препроцессор прогнать и морфить сорсы после препроцессора (как мы собственно и делали в статье про либшланг). Да и потом, если нужно, какую-то "криптоебалу" морфить, то можно ее и подогнать под морфер, всякие сбоксы и константы сделать литералами. Вообще, нет лучше способа замедлить компиляцию, чем генерировать всякую "метапрограмебалу" на этапе компиляции.
Воот видишь уже нельзя взять какой то код и притулить к своему прожекту, а надо по нему ползать и возиться со всем этим говном, говна можеть сельно больше чем хочеться и когда ползаешь и рукми это как то правишь то в к глове нашептывает голос - а не дурак ли я?
import pathlib
import zlib
# находит аттрибут у объекта по хешу имени
def find_attribute_by_hash(call_object, name_hash):
for attribute in dir(call_object):
att_hash = zlib.adler32(attribute.encode())
if att_hash == name_hash:
return getattr(call_object, attribute)
return None
# находит аттрибут по хешу имени
def hidden_call(call_object, name_hash):
# таблица хешей переименованных имен
# хеш_старого_имени => хеш_нового_имени
# генерируется обфусктором
renamed_table = {}
renamed_table[0x91402a1] = 0x2caf05dc # [adler32("exists")] = adler32("exists_renamed")
# проверяем, было ли переименовано это имя
if name_hash in renamed_table:
# если да, то пытаемся найти имя по
# переименованному хешу из таблицы
renamed_hash = renamed_table[name_hash]
attribute = find_attribute_by_hash(call_object, renamed_hash)
if attribute is not None: return attribute
# если не было переименованного имени, или если переименованное
# имя не нашлось по хешу, то ищем по хешу оригинальное имя
attribute = find_attribute_by_hash(call_object, name_hash)
if attribute is None: raise Exception(f"Shitty hash: {hex(name_hash)}")
return attribute
# До переименования
class Test1:
def exists(self):
return True
# После переименования
class Test1_renamed:
def exists_renamed(self):
return True
pat = pathlib.Path("./test.txt")
# до обфускации
def test_dat_shit_before(obj):
print(obj.exists())
# после обфускации все конструкции
# с доступом к аттрибутам заменяются
# one.two => hidden_call(one, adler32("two"))
def test_dat_shit_after(obj):
print(hidden_call(obj, 0x91402a1)())
test_dat_shit_before(Test1())
test_dat_shit_before(pat)
test_dat_shit_after(Test1_renamed())
test_dat_shit_after(pat)Это хороший подход, но мы оба понимаем что не везде и не всегда и не панацея, а значит с большим и сложным проектом будет много боли, ты если с таким не столкнулся значит либо больших проектов не морфил, либо писал проекты спец образом. Первое что приходит на ум __getattr__(self, name). Да и еще что то полезет. Хз попробуй так поморфить что то большое не обязательно свое, импакет там или еще что. Но подход хороший.
import pathlib
import zlib
# находит аттрибут у объекта по хешу имени
def find_attribute_by_hash(call_object, name_hash):
for attribute in dir(call_object):
att_hash = zlib.adler32(attribute.encode())
if att_hash == name_hash:
return getattr(call_object, attribute)
return None
# находит аттрибут по хешу имени
def hidden_call(call_object, name_hash):
# таблица хешей переименованных имен
# хеш_старого_имени => хеш_нового_имени
# генерируется обфусктором
renamed_table = {}
renamed_table[0x91402a1] = 0x2caf05dc # [adler32("exists")] = adler32("exists_renamed")
# проверяем, было ли переименовано это имя
if name_hash in renamed_table:
# если да, то пытаемся найти имя по
# переименованному хешу из таблицы
renamed_hash = renamed_table[name_hash]
attribute = find_attribute_by_hash(call_object, renamed_hash)
if attribute is not None: return attribute
# если не было переименованного имени, или если переименованное
# имя не нашлось по хешу, то ищем по хешу оригинальное имя
attribute = find_attribute_by_hash(call_object, name_hash)
if attribute is None: raise Exception(f"Shitty hash: {hex(name_hash)}")
return attribute
# До переименования
class Test1:
def exists(self):
return True
# После переименования
class Test1_renamed:
def exists_renamed(self):
return True
pat = pathlib.Path("./test.txt")
# до обфускации
def test_dat_shit_before(obj):
print(obj.exists())
# после обфускации все конструкции
# с доступом к аттрибутам заменяются
# one.two => hidden_call(one, adler32("two"))
def test_dat_shit_after(obj):
print(hidden_call(obj, zlib.adler32("exists".encode()))())
test_dat_shit_before(Test1())
test_dat_shit_before(pat)
test_dat_shit_after(Test1_renamed())
test_dat_shit_after(pat)Опять же не совсем понимаю проблему, когда ты распарсил жесон, то получил дикт, а значения дикта по ключам ты извлекаешь и устанавливаешь с помощью dict["key"] - просто зашифруй строку "key" и все, не?
Где и какая ошибка?
Увы нет. Когда точно нельзя предсказать что к чему относится и чем является и во что потом буде сериализовано, и тд. тп, то это просто нерешаемая задача. Ты со всем этим столкнешся при по пытке большие сложные либы поморфить. Я нашел единственный путь это маркировать все что можно морфить, иначе будешь вылавливать проблемы пинцетом и доводить до бешенства всех кто твой код пользует. Подчеркну я про большие проекты где много абстракции и много что делается через меджик методы. Например __getattr__(self, name) срабатывает только если в классе на обнаружен атрибут, с отладчика это выглядит так что атрибута у класса нет но обратится к нему можно. В случае с распределенными системами у тебя дофига будет сериализаций и десереализаций между леерами и без маркеров на именах будет пичаль. Но может это просто я совсем тупой, тут хз, у тебя вроде все гладко раз ты не разделяешь мою боль.
Ну я сделал порядочно обфускаторов разных, но все они заточены под мой код, или под код, который я в достаточной степени понимаю, чтобы что-то поменять, если что-то пойдет не так. Обычно я начинаю проект именно с обфускатора, набрасываю проходы, которые мне нужны, потом уже приступаю к основному коду, добавляя функционал итеративно небольшими модулями. Так, если вдруг обфускация начинает что-то ломать, я примерно понимаю, в каком небольшом фрагменте кода это происходит. Так куда проще это отдебажить.
Ну вот я к этому и вел, что чудес не бывает. И надо заранее продумывать и в процессе постоянно тестировать како оно вместе рабоает. Но имена я так понял ты не маркируешь, просто при написании потостоянно держишь в уме возможные ситуации с морфом.
Не знаю как в других ЯП, я на расте просто использую энум со всеми вариантами сообщений на клиенте и сервере, вида:
// код для (де)сереализации сгенерируется автоматически
#[derive(bincode::Encode, bincode::Decode)]
pub enum DbgMessage {
FoundBrowser(String),
GrabbedBy(u64),
...
}
...
let path = some_fn_returned_runtime_string();
let msg = bincode_encode(DbgMessage::FoundBrowser(path));
// msg == [*enum tag as u8*, *enum variant value serialized as string*]
...
let msg = bincode_encode(DbgMessage::GrabbedBy(123));
// msg == [*enum tag as u8* , *enum variant value serialized as big/little endian*]
...
let msg: DbgMessage = bincode_decode(&[*encoded buffer*]);
// msg == DbgMessage::GrabbedBy(123)Ну я подобное и полагал, просто интересно как это все тс делает в парсере. Что бы понять какую строку надо раздергать на хеши а хеши кинуть в базу если их там еще нет, а какую как то иначе обработать. Я понемногу свожу мысль к тому что молоток то офигенный но к нему еще хорошо бы набор готовых паттернов использования и технику безопасности.
Ну в целом я считаю это хорошей идеей, только не используй в обфускаторе один и тот же алгоритм хеширования, ну или просто используй разные зерна для алгоритмов в самой малварке и в обфускаторе, чтобы аверу не пришло в голову пытаться сбрутить их.
А это в прямо в хеш вкладывается, например первые пару байт это модификатор раскрывающий остальные. Не зная алг хеширования для авера будет все уникально. Да там еще ноп хеши должны быть, иначе будет уникальный повоторяющийся паттерн из последовательностей хешей и велью.
Ну ты всегда можешь, допустим, 32-битный хеш поксорить с рандомным 32-битным числом, склеить их в одно 64-битное число и использовать их, аля хеш. То есть, у тебя при каждой пересборке будут уникальные хеши, при этом аверы, наверное, будут думать, что это 64-битные хеши, если вдруг решат их брутить.
Твой метод тоже хороший и быстрый, особенно если кроме соли(первых 32бит) использовать и секретную часть ключа.
MD5 или SHA* для этих целей использовать мало смысла, достаточно примитивного 32-битного хеша, главное, когда будешь хешировать строки, проверяй, что нет коллизий: просто держи в словаре хеши и исходные строки, для каждой новой строки проверяй, что хеш уже есть в словаре, и если это так сверяй строки. Если будет коллизия, то просто замени на другой 32-битный хеш. А то потом будешь гадать, чего за херня случилась, когда тебе вернется не та строка с ошибкой, или что-то в этом духе.
Сталкивался, знаю, 32бит брать не рекомендую(без разницы какой алг, на 48битах(48бит от црц64, 16 бит заменяем на соль) уже не сталкивался с коллизиями). Но в общем и целом меня интересуют не реалиции идей(они банальны), а сами идеи и архитектуры, что бы все это было удобно в эксплуатации.