Proof-Carrying Authentication∗

Proof-Carrying Authentication∗ Andrew W. Appel and Edward W. Felten Secure Internet Programming Laboratory Department of Computer Science Princeton University Princeton, NJ 08544 USA August 9, 1999 Abstract Statements in these frameworks are represented as data structures that are often digitally signed We have designed and implemented a general to ensure their integrity. and powerful distributed authentication framework based on higher-order logic. Authenti- Several authentication frameworks exist; we cation frameworks — including Taos, SPKI, mention a few here as examples. The Taos SDSI, and X.509 — have been explained using operating system provided support for secure logic. We show that by starting with the logic, remote procedure call and data structures to we can implement these frameworks, all in the represent authority and identity [6]. X.509 [15] same concise and efficient system. Because our is a widely-used standard for expressing and us- logic has no decision procedure — although ing digital certificates. SPKI [4] and SDSI [14] proof checking is simple — users of the frame- (since merged under the joint name SPKI) work must submit proofs with their requests. were reactions to the perceived complexity of X.509; in both cases the ‘S’ stands for ‘simple.’ 1 Introduction PolicyMaker [3] is a language for expressing security policies; it can be applied to distributed Distributed authentication frameworks allow security policies. Kerberos [12], unlike the other sharing of access to resources across adminis- frameworks, uses symmetric-key encryption to trative boundaries in a distributed system. The authenticate users. Each framework has a main abstractions they support are name-to- differerent semantics and offers a different kind key bindings, access control, and delegation. of flexibility. ∗To appear in 6th ACM Conference on Computer and Formal logic has been used successfully to Communications Security, November 1999. explain authentication frameworks and proto- Copyright c 1999 by the Association for Computing Machinery, Inc. Permission to make digital or hard cols, most notably in the design of the Taos copies of part of this work for personal or classroom distributed operating system [1, 6]. The design- use is granted without fee provided that copies are not ers of Taos started by constructing an elegant made or distributed for profit or commercial advantage and expressive logic of authentication as an ex- and that copies bear this notice and the full citation on the first page or intial screen of the document. tension of propositional calculus. They proved Copyrights for components of this work owned by others this logic sound — any provable statement is than ACM must be honored. Abstracting with credit is true in all models — which makes the logic permitted. To copy otherwise, to republish, to post on an attractive basis for constructing a system. servers, or to redistribute to lists, requires prior specific However, since they wanted a server presented permission and/or a fee. Request permissions from Publications Dept., ACM Inc., fax +1(212)869-0481, or with a request to be able to decide whether [email protected]. to grant the request, they chose to implement 1 only a decidable subset of their authentication rules, they can safely interoperate: We can take logic. In a decidable logic, there is an algorithm one theorem proved using the SPKI definitions, for determining the truth (or falsehood) of any and another proved using Taos definitions, and statement. combine them to prove access even to a server Using a simple and decidable logic would that has seen neither set of definitions before. have had advantages: it’s easier to prove Although we have expressed SPKI in our metatheorems such as “there’s no way Alice logic, we don’t really recommend the use of can access the file bar.” Why, then, do we SPKI 5-tuples for authorization; the operators use an undecidable logic? Previous approaches weoutlineinsections4and5seemmore have taken a set of basic inference rules and natural. added application-specific inference rules to make application-specific logics; but the new 2 An Example rules must be trusted, i.e. proved sound. Suppose three principals, a client Alice, a By allowing quantification over predicates, we file server Bob, and a certification authority can use a single set of inference rules, with Charlie, are interacting across a network. (See application-specific rules proved as lemmas; Figure 1.) Bob receives a request to “read therefore, the application-specific rules can be foo.” Bob’s access control list says that a used to prove access requests to servers that principal called Alice can read foo — but is know only the basic logic. However, logics the request from Alice? Bob trusts Charlie with quantification over predicates – higher- to guarantee key-to-name bindings, and Bob order logics – tend to be undecidable: there is knows that Charlie’s key is K . Alice has no general algorithm for producing proofs of all c obtained a certificate signed by K that “K true statements. c a is Alice’s key,” and uses Ka to sign “read foo.” Still, a server presented with a request must Armed with all of this information, Bob can be able to figure out what to do. We solve safely grant the request to read foo. this problem by analogy with proof-carrying Our framework can express this as follows. code [9]: the client desiring access must con- We can treat “read foo” as an uninterpreted struct a proof, and the server will simply check atom, meaning that the logic doesn’t know that proof. Even in an undecidable logic, proof what it means although the participants do. checking can be simple and efficient. We put the Digital signing is a primitive of our logic, so burden of proof on the requester. We will show (Ka signed read foo) is a statement of the logic. several different strategies by which requesters Each principal is modeled as the set of can construct proofs, for example by picking formulas that she will admit as true. Thus, an application-specific decidable subset of our Alice( x.x x)meansthatAlice is willing to general logic. claim∀ that→ ( x.x x). That’s not admitting Each of the existing frameworks has chosen much, as the∀ statement→ is a tautology! But a particular set of concepts and abstractions: in fact any principal is required to admit any a particular form of delegation, a key-binding statement provable from other statements she mechanism, certain access control rules, and so admits. on. Although these choices are as reasonable as We translate the statement “Alice wants to any, no set of choices is right for everybody. By read foo” as Alice(read foo). We translate using higher-order logic, our framework allows “read foo if Alice says to” as follows: the specification and use of new abstractions and new variants on the existing abstractions. Alice(read foo) read foo. Since all the application-specific logics are → expressed using the same general inference Charlie’s certification that Ka is Alice’s key 2 Charlie Certification Authority Key certificate: OK to read foo? I want to 01001110=sign(K , keybind(K , Alice)) read foo. c a Prove it to me! Request: read foo Bob Alice Proof: [S1: signature 10010111 Ka ReadFoo] [S2: signature 01001110 Kc (keybind Ka Alice)] controls_e A3 (keybind_e (controls_e (trustedCA_e A1) A1: trustedCA(Charlie) (keybind_e A2 S2)) A2: keybind(Kc,Charlie) S1). A3: controls(Alice, read foo) Figure 1: Distributed authentication. we translate as that c is a trusted certification authority: if c says some key binding, we can trust Kc signed ( F. (Ka signed F ) (Alice(F ))). that key binding. ∀ → Bob’s knowledge of Charlie’s key is stated as These particular definitions may be well- suited to our example transaction, but they are F. (Kc signed F ) Charlie(F ). hardly likely to be general enough for the real ∀ → world. The strength of our approach is that Finally, Bob’s trust in Charlie is expressed as a it does not “build in” a fixed set of definitions memorandum to himself: but allows the participants in each application to define and use their own abbreviations. k. p. Some useful lemmas follow immediately from Charlie∀ ∀ (( S. (k signed S) p(S))) these definitions. For example, we can prove S. (k signed∀ S) p(S).→ → ∀ → the lemma controls e, which states that if These statements are expressed in a higher- p controls S and p says S,thenS is true: order logic (i.e., one in which we can quantify p controls Sp(S) over formulas and predicates), with inference controls e S rules given in Figure 3. Since these statements are rather unwieldy, Additional lemmas allow one to use state- it is only natural for the participants to have ments by a trusted certification authority, and agreed upon some definitions: to make inferences from key bindings: trustedCA(c) keybind(k, p) stands for trustedCA e S. (k signed S) p(S). That is, k is p’s c controls keybind(k, p) key,∀ so that if k→signs some statement S keybind(k, p) k signed S then p should be considered to believe it. keybind e p(S) p controls S stands for p(S) S.Thatis,p “controls” the statement S→,soifp says S 2.1 Constructing a proof. then S will be considered true. Bob starts with the following assumptions in his security database: trustedCA(c) stands for k. p. c controls keybind(k, p), meaning A1 = trustedCA(Charlie) ∀ ∀ 3 trustedCA(C) keybind(K ,C) K signed keybind(K ,A) trustedCA e c c a keybind e C controls keybind(K ,A) C(keybind(K ,A)) a a controls e keybind(K ,A) K signed read foo a a keybind e A controls read foo A(read foo) controls e read foo Figure 2: Proof that Alice can read foo.

Load more