[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Delegation & Agreement Based Policy
In my previous post I suggested a Byzantine contract paradigm for
certificate policy, especially concerning delegation. Instead of
giving "permission" to delegate, assume that any entity (and, in particular, the
beneficiary of an authorization) will do whatever it likes unless (a) it promises not
to (or the specification promises that it won't), and (b) this promise is enforceable
by the verifier, or at least non-performance on this promise is verifiable.
Assume as well that third parties will do whatever they like unless prevented.
This is the pessimistic assumptions used in distributed computing theory (the
Byzantine generals problem in particular comes to mind); it applies all the more
when dealing in the security of distributed systems. "Fraud", poorly defined
in other security methodologies, is well defined in the contractual
paradigm as being a breach of a specific agreement.
In some cases authorization policies are self-enforcing, and we can rely on
bearer certificates. Otherwise, verification and enforcement rely on observation
of the behavior of an object, often persistence of behavior across many
authorizations to it. One method of facilitating this observation is via public
key-object bindings. These bindings may be certified by some authority, but
this is a weak (not self enforcing, and not even strongly verifiable) kind of
authorization due to a variety of identification frauds: identity lending, identity
theft, man-in-the-middle, etc. To be useful these bindings must be
further associated with "reputation" information, via observing the persistence
of behavior associated with the public key. With such bindings we can have
non-bearer, or identified, certificates. We can then make authorizations which are
non-delegable up to the non-delegability of the public key-object binding.
To partake of such a non-delegatory service one must hold not only an
authorization certificate, but also an identity certificate. If either the
specific authorization or the authentication via identity certificate fails,
the authorization fails. This combination gives an identified authorization certificate.
With identified certificates we've reduced a wide variety of possible delegation frauds
down to identification fraud. Of course, solving the several varieties identification
fraud is still difficult, but at least we've reduce a bunch of nebulous delegation
problems down to a well-defined one. Besides the weakness of solutions to
identification fraud, and the need to further bind to reputation information
for identity to be useful, identity certificates also introduce a major source of
confidentiality loss, especially due to traffic analysis. But many consider
these prices worth paying due to the lack of bearer certificate solutions to
Non-bearer certificates require the verifier to have trustworthy verifications chains
for the identity certificates of all entities to be verified, as well as the chain(s) for
the particular authorization itself. The identification certificates cannot, as
far as way know, ever be made as strongly secure as delegable
In many situations we don't really care about delegation. If for example we are
only interested in limiting the usage of a service or associated resources, the
identity of the user is irrelevant. In these cases we can issue bearer certificates,
usable N times. This is strongly enforceable via clearing lists, with no delegation
I suggest the follow principles for determining when certificate chains should
be automatically followed:
* "Trust" cast in narrow, very specific terms: "trust to specifically X"
* These specific terms converted into proactive, self-enforcing protocols when
* When a self-enforcing protocol is not possible, strong verification of these
specific terms through unforgeable auditing trails and frequent verification
checks should be instituted.
* Otherwise, the "chain of trust" is in computer security terms very weak, relying
on ill-defined human trust and institutions rather than on the security properties
of the software. The user interface should prominently make this known to the users,
and allow the users to input their judgements regarding these people and
institutions. Confusing human with computer security makes great deceptions possible.
More articles about the contractual paradigm, blacklisting (negative reputation
systems), enforcement, verification, and related topics can be found on my web page.