Burrows-Abadi-Needham logic

Burrows-Abadi-Needham logic (also known as the BAN logic) uses postulates and definitions like all axiomatic systems to analyze authentication protocols. Use of the BAN logic often accompanies a security protocol notation formalation of a protocol. The definitions and their implications are below (P and Q are network agents, X is a message, and K is an encryption key[?]):

• P believes X = P acts as if X is true, and may assert X in other messages.
• P has jurisdiction over X = Ps beliefs about X should be trusted.
• P said X = At one time, P transmitted (and believed) message X, although P might no longer believe X.
• P sees X = P recieves message X, and can read and repeat X.
• {X}_K = X is encrypted with key K.
• fresh(X) = X was sent recently.
• key(K, P<->Q) = P and Q may communicate with shared key K

The meaning of these definitions is captured in a series of postulates:

• If P believes key(K, P<->Q), and P sees {X}_K, then P believes (Q said X)
• If P believes (Q said X) and P believes fresh(X), then P believes (Q believes X).

P must believe that X is fresh here. If X is not known to be fresh, then it might be an obsolete message, replayed by an attacker.

• If P believes (Q has jurisdiction over X) and P believes (Q believes X), then P believes X

• There are several other technical postulates having to do with composition of messages. For example, if P believes that Q said <X, Y>, the concatenation of X and Y, then P also believes that Q said X, and P also believes that Q said Y.

Using this notation, the assumptions behind an authentication protocol can be formalized. Using the postulates, one can prove that certain agents believe that they can communicate using certain keys. If the proof fails, the point of failure usually suggests an attack which compromises the protocol.

The Wide-Mouthed Frog Protocol

A very simple protocol allows two agents, A and B, to establish secure communications, using a trusted authentication server, S, and synchronized clocks all around. Agents A and B are equipped with keys K_as and K_bs, respectively, for communicating securely with S. So we have assumptions:

A believes key(K_as, A<->S)

S believes key(K_as, A<->S)

B believes key(K_bs, B<->S)

S believes key(K_bs, B<->S)

Agent A wants to intiate a secure conversation with B. It therefore invents a key, K_ab, which it will use to communicate with B. A believes that this key is secure, since it made up the key itself:

A believes key(K_ab, A<->B)

B is willing to accept this key, as long as it is sure that it came from A:

B believes (A has jurisdiction over key(K, A<->B))

Moreover, B is willing to trust S to accurately relay keys from A:

B believes (S has jurisdiction over (A believes key(K, A<->B)))

That is, if B believes that S believes that A wants to use a particular key to communicate with B, then B will trust S and believe it also.

The goal is to have

B believes key(K_ab, A<->B)

A reads the clock, obtaining the current time t, and sends the following message:

1 A->S: {t, key(K_ab, A<->B)}_Kas

That is, it sends its chosen session key and the current time to S, encrypted with its private authentication server key K_as.

Since S believes that key(K_as, A<->S), and S sees {t, key(K_ab, A<->B)}_Kas, then S concludes that A actually said {t, key(K_ab, A<->B)}. (In particular, S believes that the message was not manufactured out of whole cloth by some attacker.)

Since the clocks are synchronized, we can assume

S believes fresh(t)

Since S believes fresh(t) and S believes A said {t, key(K_ab, A<->B)}, S believes that A actually believes that key(K_ab, A<->B). (In particular, S believes that the message was not replayed by some attacker who captured it at some time in the past.)

S then forwards the key to B:

2 S->B: {t, A, A believes key(K_ab, A<->B)}_Kbs

Because message 2 is encrypted with K_bs, and B believes key(K_bs, B<->S), B now believes that S said {t, A, A believes key(K_ab, A<->B)}. Because the clocks are synchronized, B believes fresh(t), and so fresh(A believes key(K_ab, A<->B)). Because B believes that Ss statement is fresh, B believes that S believes that (A believes key(K_ab, A<->B)). Because B believes that S is authoritative about what A believes, B believes that (A believes key(K_ab, A<->B)). Because B believes that A is authoritative about session keys between A and B, B believes key(K_ab, A<->B). B can now contact A directly, using K_ab as a secret session key.

Now let's suppose that we abandon the assumption that the clocks are synchronized. In that case, S gets message 1 from A with {t, key(K_ab, A<->B)}, but it can no longer conclude that t is fresh. It knows that A sent this message at some time in the past (because it is encrypted with K_as) but not that this is a recent message, so S doesn't believe that A necessarily wants to continue to use the key K_ab. This points directly at an attack on the protocol: An attacker who can capture messages can guess one of the old session keys K_ab. (This might take a long time.) The attacker then replays the old {t, key(K_ab, A<->B)} message, sending it to S. If the clocks aren't synchronized (perhaps as part of the same attack), S might believe this old message and request that B use the old, compromised key over again.

The original Logic of Authentication paper (linked below) contains this example and many others, including analyses of the Kerberos handshake protocol, and two versions of the Andrew RPC handshake (one of which is defective).

Offsite Links

• A Logic of Authentication (http://citeseer.nj.nec.com/burrows90logic), the original paper by Burrows[?], Abadi[?], and Needham.
• Source: The Burrows-Abadi-Needham logic (http://www.pasta.cs.uit.no/thesis/html/ronnya/node31)