Key Distribution/Management

and Authentication

two closely related subjects

why?

Key Distribution

symmetric encryption schemes require both

parties to share a common secret key
issue is how to securely distribute this key without
revealing it to an adversary

many attacks are based on poor key

management and distribution
rather than breaking the codes

This is, actually, the most difficult problem in

developing secure systems

Key Distribution
various key distribution alternatives for parties A and B:
1. A can select key and physically deliver to B

does not scale for a large and distributed group

how many keys do we need for N users?

2. third party can select & physically deliver key to A &

B

similar comment as 1
sometimes finding a trusted third party is another problem

3. if A & B have communicated previously, they can use

previous key to encrypt a new key

good option but initially several keys to be distributed

4. if A & B have secure communications with a third

party C, C can relay key between A & B on demand

only N master keys are enough

Session Key / Master Key

The idea of having a key-encryption-key

(master key) to generate random and
temporary session keys
can be implemented in several ways
Basic D-H is such an example
public/private keys are master keys, exchanged key is a
session key

Kerberos is another example

SSL uses three layers
D-H for master key, master key for the session key

Session Key / Master Key

Session key lifetime is a trade-off

if small
securer since attacker can obtain less
ciphertext to analyze
But this creates more delay

If large
less secure, but less delay

Key Distribution Facts

Conservation of trust principle

a secure communication cannot be based on
nothing; either there should be an initial direct
contact or an indirect protocol to transfer trust

Either physical delivery or a trusted third party

physical delivery is the only option to avoid a third
party
most basic system is PIN entry

otherwise regardless of symmetric or asymmetric

encryption, you need a trusted third party
even D-H does not work without a third party, why?

A Key Distribution Example

Symmetric crypto based

Each user shares a symmetric master key
with the KDC (Key Distribution Center)
e.g. Ka, Kb, Kc,
possibly physically distributed

Basic idea:
whenever a user A wants to communicate with B,
it requests a session key (Ks) from KDC

Protocol is in the next slide

A Key Distribution Example

Assures that message 3

is not a replay

Key Management in Public Key

Cryptography

In other words
distribution of public keys
use of Public Key Cryptography to
distribute secret keys
public/private key as a master key

Distribution of the Public Keys

the most important barrier against the

deployment of PKC in applications
Basic question?
how can I make sure about the legitimacy of a
public key?
how can I make sure that Bobs public key really
belongs to Bob, not to Charlie?

Why this is so important?

Name spoofing attacks become possible
remember the man-in-the-middle attacks in anonymous
Diffie-Hellman

Distribution of the Public Keys

Some methods
Public Announcement
Publicly available databases/directories
Centralized distribution
Certificates

Public Announcement

Broadcast your public key to the public

via newsgroups, mailing lists, from
personal website, etc.
major weakness is anyone can easily
pretend as yourself
so attacks are possible

Publicly available
directories/databases
There exists a directory/database for
{name, public key} pairs
write controlled

a trusted administrator

if administered thoroughly, good

but a proper administration is difficult
need secure mechanisms for registration,
update, delete.

Centralized Distribution - PublicKey Authority

Similar to directory/database approach, but

access to the directory is automated via a
secure protocol
users interact with directory to obtain any desired
public key securely
requires real-time access to directory when keys
are needed
users should know public key for the directory

the directory/database contains {name, public

key} pairs
write permit is restricted

Centralized Distribution - PublicKey Authority PROTOCOL

Authentication
Messages

Centralized Distribution - PublicKey Authority

What about caching the public keys at

the end users?
good for performance
saves some messages

but what happens if a public key is deleted

form the database/directory?
fresh copies needed or another protocol for the
validity check

Centralized Distribution - PublicKey Authority

Disadvantages
authority is an active entity and may create
a performance bottleneck
database should be kept secure to prevent
unauthorized modification

The problem of registration of public-keys

is still unsolved!

Public-Key Certificates

certificates allow key exchange without realtime access to public-key authority

a certificate binds identity to public key
usually with other info such as period of validity,
issuers info, etc

all contents signed by a trusted Certification

Authority (CA)
can be verified by anyone who knows the CA
public-key
CA must make sure about the identity of the
certificate owner

Public-Key Certificates

Public-Key Certificates

Certificates are widely used in practice

previous slides only show the idea

need lots of polishing for practical use

is a single CA sufficient?
what happens if the CAs public key is not known?
how to distribute CA public keys?

what happens if a certificate is revoked?

How the users exchange their certificates in
practical applications?

We will discuss the use of certificates and

state-of-the-art in this area later

What can you do with securely

distributed public keys?

Digital signatures
talked about them

confidentiality
theoretically possible but slow
instead session keys can be distributed
those session keys are used for symmetric
encryption

Distribution of Secret Keys using

PKC
Several methods exist
Diffie-Hellman is one way
we will see some alternatives

Simple Secret Key Distribution

proposed by Merkle in 1979

A generates a new temporary PKC key pair
A sends B its public key and identity
B generates a session key and sends it to A
encrypted using the supplied public key
A decrypts the session key and both use it

Simple Secret Key Distribution

problem is that an opponent can intercept

and impersonate both parties of protocol
man-in-the-middle attack
result: A and B think that they exchanged Ks
securely but C also knows Ks and use it to
eavesdrop the communication passively
PUc

C
E(PUa, Ks)

E (PUc, Ks)

Public-Key Distribution of Secret

Keys

assumption: public-keys are securely exchanged a

priori
First three steps are for authentication purposes
Last step provides both the secrecy and authenticity
of the session key

In practice

Most systems offer a three-level

approach
use of PKC to exchange master-key
use of master-key to exchange session
keys

most important advantage is at

performance

A closer look to authentication

making sure of peer entitys identity

mutual or one-way
non-repudiation is not an aim here

generally implemented as a protocol

basic idea: making sure that other party knows a
common secret
also used for session key distribution

two types
message authentication
mostly one-way

peer entity authentication

connection oriented approach

Two key issues

Protection of any secret information
Timeliness

to prevent replay attacks

a valid message is copied and later resent

Why replays are bad?

at minimum, disrupt proper operation by
presenting messages that appear genuine but
actually are not
Think about a real world example!

Countermeasures - 1

Sequence numbers
not a practical method
parties should keep track of the sequence
numbers
and should take care of message losses,
duplications in a secure manner
complicates the protocol

Countermeasures - 2

Timestamps
messages contain a timestamp
accept only fresh messages based on this
timestamp
sometimes used, but there are some
practical problems
clocks must be synchronized in a secure
manner (if the timestamp generated by a party
will be checked by another party)
tolerance to network delays

Countermeasures - 3

Challenge/response
Initiator sends a nonce (a challenge phrase
or number used only one-time) and
expects that nonce (or a transformation of
it) in the response
easier to implement
but may require extra message transfer
and requires active parties
not suitable for connectionless services

and requires the generating parties to

check the uniqueness of generated nonces

Authentication using Symmetric

Encryption

We start with well-known NeedhamSchroeder protocol

actually have seen it as a key distribution protocol

There exists a Key Distribution Center (KDC)

each party shares own master key with KDC
KDC generates session keys used for connections
between parties
master keys are used to distribute these session
keys in a secure way

Needham-Schroeder Protocol

three-party key distribution protocol

for session between A and B, mediated by a trusted
KDC
KDC should be trusted since it knows the session key

protocol overview
1. AKDC: IDA || IDB || N1
2. KDCA: E (Ka,[Ks || IDB || N1 || E (Kb,[Ks||IDA]) ])
3. AB: E (Kb,[Ks||IDA])
4. BA: E (Ks,[N2])
5. AB: E (Ks,[f(N2)])

4 and 5 prevent a kind of a replay attack

against replay of message 3 by an attacker

Needham-Schroeder (NS) Protocol

but still vulnerable to a replay attack

if an old session key has been compromised, then
message 3 can be resent to B by an attacker X
impersonating A
after that X intercepts message 4 and sends a
message 5 to B as if it is A
now X can impersonate A for the future
communications with the session key
unlikely but a vulnerability (at least X has infinite
amount of time to break the session key)

modifications to address this problem

timestamps (Denning 81), B contacted at the
beginning (Needham Schroeder 87)

see http://www.lsv.ens-cachan.fr/Software/spore/table.htm l for a

repository of security protocols

NS Protocol with timestamps

proposed by Dorothy Denning in 1981
A and B can understand replays by
checking the timestamp in the message

even if attacker knows Ks, he cannot

generate message 3 with a fresh timestamp
since he does not know Kb
1. AKDC: IDA || IDB
2. KDCA: E (Ka,[Ks || IDB || T || E (Kb,[Ks||IDA||T])])

3. AB: E (Kb,[Ks||IDA||T])
4. BA: E (Ks,[N1])
5. AB: E (Ks,[f(N1)])

Needham Schroeder Protocol

Revisited

Amended by the creators themselves in 1987 by

putting B in the loop early in the protocol
http://doi.acm.org/10.1145/24592.24593

1.
2.
3.
4.
5.
6.
7.

A -> B
B -> A
A -> KDC :
KDC -> A :
A -> B :
B -> A :
A -> B :

: IDA
: E (Kb, [IDA || Nb])
IDA || IDb || Na || E (Kb,[IDA || Nb])
E (Ka, [Na || IDb || Ks || E (Kb, [Ks || Nb || IDA])])
E (Kb, [Ks || Nb || IDA])
E(Ks, [Nb])
E(Ks, [f(Nb)])

Synchronization problem

Proper use of timestamps requires synchronized

clocks
e.g. when senders clock is ahead of recipients
clock
attacker can intercept the message and replay later

Neuman and Stubblebine in 1993 proposed use of

nonces with timely session keys to constitute tickets
Nonces and timestamps are used together
Nonces are to avoid replays. Nonces are also used in
challenges/response framework
timestamps are expiration dates of the session key established

attacker only has a limited time to break the session key

in original NS, attacker has unlimited time to break the session
key

Neuman Protocol
1. A -> B
: IDA || Na
2. B -> KDC : IDB || Nb || E (Kb, [IDA || Na ||Tb])
3. KDC -> A :E (Ka,[IDB || Na || Ks || Tb]) || E (Kb, [IDA||Ks ||Tb])||Nb
4. A -> B : E (Kb, [IDA || Ks || Tb]) || E(Ks, [Nb])

E (Kb, [IDA || Ks || Tb]) is a ticket that can be

used later within the limit of Tb

1. A -> B
2. B -> A
3. A -> B

: E (Kb, [IDA || Ks || Tb]) || Na

: Nb || E(Ks, [Na])
: E(Ks, [Nb])

Important Question: Do we need synchronized

clocks between A & B to ensure freshness?

Authentication using Public-Key

Encryption
We have given an example method that
assumes public keys are known
There exists protocols that also
distributes public keys

using a central Authentication Server (AS)

or KDC
using timestamps or nonces

A timestamp approach

Denning (in 1981) presented the following:

1. AAS: IDA || IDB
2. ASA: E (PRas, [IDA||PUa||T]) || E (PRas, [IDB||PUb||T])
3. AB: E (PRas, [IDA||PUa||T]) || E (PRas, [IDB||PUb||T]) ||
E (PUb, [E(PRa, [Ks||T])])

note that session key is chosen by A, hence AS

need not be trusted to protect it
timestamps prevent replay but require
synchronized clocks

A nonce approach

Proposed by Woo and Lam (1992)

nonces are not sent in clear

SEE THE PROTOCOL in Stallings page 494495

One-Way Authentication

required when sender & receiver are not online

at same time
e-mail is a typical application
protocol should not rely on the processing of receiver

A symmetric encryption approach

1. AKDC: IDA || IDB || N1
2. KDCA: E (Ka, [Ks || IDB || N1 || E (Kb, [Ks||IDA])])
3. AB:
E (Kb, [Ks||IDA]) || E(Ks, [M])

Provides authentication that the sender is A

does not protect against replays (of msg. 3)
could rely on timestamp in message, but delays in
email make this problematic

Public-Key Approaches
have seen some public-key approaches
if confidentiality is major concern, can use:

AB: E (PUb, [Ks]) || E(Ks, [M])

digital envelopes

if authentication needed, use a digital

signature with a digital certificate:
AB: M || E (PRa, [H(M)]) || E (PRas, [T||IDA||PUa])
message, signature, certificate

We will detail e-mail security issues later

X.509 Authentication Protocols

X.509 is a ITU-T standard part of the

directory services
mostly for certificates, but also propose
three generic authentication protocols
one-way authentication
two-way authentication
three-way authentication
use both nonces and timestamps
nonces are unique only within the lifetime of
timestamp
Timestamp includes expiration time

X.509 one-way authentication

Proves that the message generated by A and

intended for B
also proves that message is not a replay
proves the identity of the sender, but not the recipient
optionally includes a session key and signed
information

tA: timestamp

rA: nonce

sgnData: Data signed

X.509 two-way Authentication

both parties verify identity of each other

reply message

generated by B
not a replay (guaranteed by tB and rB)
includes rA to match the messages
Question: Do we really need tB and rB to avoid replay of
second message?
Answer is in the next protocol!

X.509 three-way Authentication

Nonces are signed and echoed back

each side can check the replay by checking its
own nonce
timestamps are not needed
synchronized clocks are not needed either
what is a potential risk in such a case?