In order to formalize secrecy properties, it is natural to use an event
at the point in a’s run of the protocol with b where we believe the protocol guarantees that Yves cannot obtain the secret value s. It expresses that expectation that the intruder cannot be in possession of s. It may be understood to mean: ‘The value s used in the run apparently between a and b initiated by a should be secret for the entire protocol run’. For example, the Yahalom protocol aims to ensure that the key kab received by a in the third message is secret. This expectation is expressed by introducing the signal message into the description of the general initiator run Initiator(a, n) as follows:
The property will require that the intruder cannot know kab in any run in which this signal is emitted. In order to express this, we can observe whether or not kab can ever appear on the say channel.
This extra use of the say channel has no impact on the attacks that Intruder can mount, since its use does not change the state S of the intruder. It is used purely to provide information about whether the intruder is in possession of particular messages. To separate this specification use of the say channel from its more common use of providing messages to protocol agents, we introduce a new leak channel to accept outputs from the say channel. The resulting network is illustrated in Figure 3.3.
Figure 3.3. Introducing a leak channel
Secrecy will be expressed as the requirement that if an agent claims that a message is secret, then the intruder should not be able to leak it. Naïvely this might be expressed as
However, the characterization of secrecy as protection from Intruder means that some care must be taken in the expression of this property. In order to express the secrecy requirement, we can in fact only require the value m to be secret in cases where a runs the protocol with another honest agent, since it is inappropriate to send a secret message to Yves and then expect the intruder not to know it.
In fact, the secrecy property we require is that: ‘m is secret provided a’s communication partner is honest and uncompromised’.
If the set Honest is the set of agents that are honest and uncompromised (in the sense that the intruder does not have their secret keys), then we can express the property that the intruder should not be in possession of m provided it is claimed to be a secret as a result of a run with an honest user. The event is introduced into the CSP description, and the property will require that if j ∊ Honest then m should not be able to appear on leak when it is claimed to be secret.
The responder is treated in an entirely similar way, with the same possibilities for introducing the signal event into the model. There is no particular need to distinguish between initiator and responder of the protocol, so exactly the same events signal.Claim_Secret.i.j.kab can be used to indicate that at the end of a run the key kab that j has accepted is intended to be secret. These events can be introduced into the protocol in exactly the same way, as follows:
The resulting system, consisting of the enhanced initiator and responder descriptions, will be denoted System′.
The specification therefore requires only that Yves should not obtain the secret s in cases where the run is with an agent outside his control. This may be expressed as the following trace specification:
The system with the initiator above meets this specification Secreta,b(tr).
It is now possible to express the complete secrecy property in terms of the signals that have been added to the protocol:
If a has completed a protocol run apparently with b, and b is honest and uncompromised, then the key accepted during that run by a is not known to anyone other than b. Similarly, if b has completed a run with honest and uncompromised a then the key accepted by b is not known to anyone other than a.
This covers the secrecy requirements of both initiator and responder, since either of them can claim that a key is secret. There is no reason in the Yahalom protocol to distinguish between initiator and responder claims of secrecy.
The discussion above was concerned with secrecy with respect to our default threat model including dishonest agents. It is clear that in such cases secrecy can only be obtained if the other party is not going to compromise the intended secret – the protocol has no control over how the intended secret is to be used afterwards. In order to capture the property as one that can be verified of the protocol, it is important to make this assumption explicit. We chose above to do this within the trace property. However, an alternative approach was available to us: the introduction of the Claim_Secret event could have been more restricted, so that it is signalled only in cases where the protocol has been run with an honest party. Since the event signal.Claim_Secret.a.b.s is introduced into the protocol purely for specification and verification purposes, we can restrict when it can be performed. We can simply ensure that Claim_Secret signals are only performed on protocol runs that are not with compromised agents from the set CS. This will embody the caveat that ‘s is secret provided a’s communication partner is honest’. The Yahalom protocol initiator’s description would then be described as follows:
The requirement will then be as it was in line 3.1: simply that if a secret is claimed, then the intruder should not be able to leak it. The honesty of the parties is now folded into the introduction of the signal event.
In the case where the only threat is external, the secrecy property is much easier to capture. It is automatic in this threat model that all agents are honest and uncompromised, and hence the requirement that s should not appear on leak does not need to be qualified. The trace property in this case is again simply that in line 3.1:
In fact this is a special case of the general threat model, in which the intruder has no keys or any identity of his own: so Yves is not a name, and the initial knowledge of the intruder IK does not contain any private keys of any agent. In this case the set of honest agents Honest is the set of all users. The specification Secret′ here is simply a special case of the specification given in line 3.2, since b ∊ Honest will always be true.
Observe that employing this threat model is equivalent to modelling protocol agents who are only prepared to initiate and respond to runs with honest users. However, this is different from (and strictly weaker than) the analysis for the internal threat model above, in which we are only concerned with secrecy in cases where an agent has engaged in a run with an honest agent. The internal threat model is concerned with Anne’s claim of secrecy after a run with honest Bob, but allows for the possibility that Bob might be involved in a run with Yves: Anne can interact with agents who are honest but lack judgement. The external threat model, and the requirement that all agents only run with honest agents, do not allow for this possibility: Anne can only interact with agents who are both honest and have good judgement.
The secrecy properties Secret(tr) expressed as a property on traces can also be captured as CSP specification processes.
We can use the following specification to capture the requirement that a’s state of mind is correct (for all a) concerning s:
The intruder Yves should only be able to perform the event leak.s if no honest agent has previously signalled that they believe that s is a secret shared with an honest agent (via an event signal.Claim_Secret.a.b.s for b ∊ Honest).
Of course, there may be several potential secrets; we will write ALL SECRETS for the set of all these secrets. We can write a single specification testing whether all these secrets really do remain secret as expected:
This specification is in terms of only leak and signal events, so if we hide all other events:
we can test whether the protocol guarantees secrecy by testing the refinement:
There is one point we have not yet considered, as it does not arise in the Yahalom protocol: at what point in the protocol should the honest agents perform the signal events? We can identify two scenarios:
The secret in question might have significance outside of the protocol itself; for example, the secret is provided as input to the protocol, and one goal of the protocol is to transfer the secret from an agent a to another agent b. In this case, the secret should not be leaked to the intruder under any circumstances, so the signal event should occur as soon as it makes sense: the process representing a would presumably have s in its state initially, so should perform the signal immediately; the process representing b should perform its signal as soon as it actually receives the secret. We will call this strong secrecy.
Alternatively, the secret might be created within the protocol run and only used if the run is successfully completed; for example, a session key would be freshly invented, but if the run does not complete successfully then presumably the key would be discarded, and so a leak of this key would not matter. In this case, the signal event can be placed at the end of the protocol run.
The sooner the Claim_Secret event appears in the run, the stronger the requirement.