Пролог - пытаться строить из начальных знаний, ограничить бесконечное строительство

Question

Я пытаюсь создать базу знаний, которая указывает на сообщения, которые злоумышленник может отправить, чтобы получить доступ к некоторым секретным данным (в моем примере используется упрощенная версия протокола TLS, то есть Client-Server-Certificate-CertificationAuthority-SessionKey).

В любом случае, если требуется дальнейшее объяснение, пожалуйста, спросите.

Моя проблема:

При использовании протокола сообщения отправляются следующим образом:

init(Init_1, Init_2, Init_3)

Это сообщение имеет 3 параметра.Каждый из параметров должен иметь специальный формат .Например:

nonce(Init_1)
publicKey(Init_2)
Init_3 = sign(SignedData, PrivateKey)
SignedData = [Id,PublicKey]
id(Id)
publicKey(PublicKey)

Кроме того, чтобы принять сообщение и отправить следующее, необходимо проверить охранника:

ext(Init_3,Init_2) % meaning the signature can be extracted with the second parameter
extractedData(Init_3,Data) % Data is the extracted data from the signature
nth(2,Data,Init_2) % the second atom of the extracted data is the same as the second parameter

Самое главное, злоумышленник может отправлять только сообщения с параметрамичто он знает.

knows(Init_1),
knows(Init_2),
knows(Init_3)

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

init(n_c , k_c , sign([c,k_c],k_c-1) )

приводит к

knows(n_c,1) % the 1 is an artifact which may or may not be needed; tells the depth of the knowledge
knows(k_c,1)
knows(sign([c,k_c],k_c-1),1)

РЕДАКТИРОВАТЬ: я удалил длинную часть о извлечении данных из зашифрованных и / или подписанных данных.По сути, после сбора сообщений по умолчанию и утверждения из них начальных знаний все расшифруемые и извлекаемые данные добавляются к начальным знаниям.

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

enc(enc(enc(enc(enc(...(Data, Key)...)

Но я хочу ограничить построение сообщений специальным форматом, описанным выше.В примере с init я хочу разрешить построение

sign([Id,PublicKey],PrivateKey)

, но не что-то вроде

sign(sign([Id,PublicKey],PrivateKey),PrivateKey)

или чего-то еще хуже.

Последнее, но не менее важноевот мое построение сообщения или правила генерации параметров правила:

knows([FirstData,SecondData],Depth) :-
Depth @> 1,
depth(SecondData,B), A is Depth - B,
knows(SecondData,B), knows(FirstData,A).

knows(enc(Data,Key),Depth) :-
Depth @> 1,
DepthMin1 is Depth - 1,
for(KeyDepth,1,DepthMin1),
isKey(Key),
Data \== enc(_, Key),
    knows(Key, KeyDepth),
knows(Data, DepthMin1).

knows(sign(Data,Signature),Depth) :-
Depth @> 1,
DepthMin1 is Depth - 1,
for(KeyDepth,1,DepthMin1),
isKey(Signature),
Data \== sign(_, Signature),
knows(Signature,KeyDepth),
knows(Data,DepthMin1).

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

РЕДАКТИРОВАТЬ:

Хорошо, возможно, проблема программирования была немного скрыта.Итак, в основном, как я могу ограничить генерацию сообщений из начальных знаний знает (Data, 1) (используя enc, sign и concatenation [,]) конечным диапазоном (определенным специальным формат выше) (т.е. не генерировать enc (enc (Data, Key), Key), если сообщение не содержит этот шаблон в первую очередь)?

Answer 1

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

Например, рассмотрите следующее:

list([]).
list([0|T]):-list(T).
list([1|T]):-list(T).

этот код распознает/ создает списки 0 и 1.если мы просто используем список (L), мы просто получим нули: [], [0], [0,0], [0,0,0] ....

однако, если мы используем длину/ 2 для списков мы получим то, что хотим:

?- length(L,X), list(L).
L = [],
X = 0 ;
L = [0],
X = 1 ;
L = [1],
X = 1 ;
L = [0, 0],
X = 2 ;
L = [0, 1],
X = 2 ;
L = [1, 0],
X = 2 ;
L = [1, 1],
X = 2 ;

однако это не избавит от шаблонов, которые вам не нужны;это только заставит это появиться позже.в этом примере, если я не хотел, чтобы списки имели нули в начале, длина / 2 недостаточно хороша (тем не менее, это помогает генерировать «значимые» результаты)

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

Еще одно решение - реорганизовать ваши предикаты.в этом примере, если вы поместите предикат 1 первым, чтобы получить списки, начинающиеся с 1 в первую очередь.или вы могли бы использовать (больше) слоев предикатов, таких как: first_list ([1 | T]: - list (T).

только некоторые идеи:)