Digest access authentication

From Wikipedia, the free encyclopedia

HTTP Digest access authentication is one of the agreed methods a web page can use to negotiate credentials with a web user (using the HTTP protocol). Digest authentication is intended to obsolete unencrypted use of the Basic access authentication, allowing user identity to be established securely without having to send a password in plaintext over the network. Digest authentication is basically an application of MD5 cryptographic hashing with usage of nonce values to prevent cryptanalysis.

Digest access authentication was originally specified by RFC 2069 (An Extension to HTTP: Digest Access Authentication). RFC 2069 specifies roughly a traditional digest authentication scheme with security maintained by a server generated nonce value.

$\mathrm{HA1} = \mathrm{MD5}\Big(\mathrm{A1}\Big) = \mathrm{MD5}\Big( \mathrm{username} : \mathrm{realm} : \mathrm{password} \Big)$

$\mathrm{HA2} = \mathrm{MD5}\Big(\mathrm{A2}\Big) = \mathrm{MD5}\Big( \mathrm{method} : \mathrm{digestURI} \Big)$

$\mathrm{response} = \mathrm{MD5}\Big( \mathrm{HA1} : \mathrm{nonce} : \mathrm{HA2} \Big)$

RFC 2069 was later replaced by RFC 2617 (HTTP Authentication: Basic and Digest Access Authentication). RFC 2617 introduced a number of optional security enhancements to Digest Authentication; "Quality of Protection" (qop), nonce counter incremented by client, and a client generated random nonce. These enhancements are designed to protect against e.g. chosen-plaintext attack cryptanalysis.

$\mathrm{HA1} = \mathrm{MD5}\Big(\mathrm{A1}\Big) = \mathrm{MD5}\Big( \mathrm{username} : \mathrm{realm} : \mathrm{password} \Big)$

$\mathrm{HA2} = \mathrm{MD5}\Big(\mathrm{A2}\Big) = \mathrm{MD5}\Big( \mathrm{method} : \mathrm{digestURI} \Big)$

$\mathrm{response} = \mathrm{MD5}\Big( \mathrm{HA1} : \mathrm{nonce} : \mathrm{nonceCount} : \mathrm{clientNonce} : \mathrm{qop} : \mathrm{HA2} \Big)$

1 Impact of MD5 security on Digest authentication
2 HTTP Digest Authentication considerations
3 Example with explanation
4 SIP Digest Authentication
- 4.1 See also
- 4.2 External links

[edit] Impact of MD5 security on Digest authentication

The MD5 calculations used in HTTP Digest Authentication is intended to be "one way", meaning that it should be difficult to determine the original input when only the output is known. If the password itself is too simple, however, then it may be possible to test all possible inputs and find a matching output (a brute force attack) – perhaps aided by a dictionary or suitable look-up list. Ideally users should be forced to use long, non-trivial passwords.

The HTTP scheme was designed at CERN in 1993 and does not represent subsequent improvements in authentication systems, such as the development of keyed-hash message authentication code (HMAC). Although the cryptographic construction that is used is based on the MD5 hash function, collision attacks were in 2004 generally believed (e.g. Hash collision news ) to not affect applications where the plaintext (i.e. password) is not known. However, claims in 2006 ( Kim, Biryukov2, Preneel, Hong On the Security of HMAC and NMAC Based on HAVAL MD4 MD5 SHA-0 and SHA-1 ) cause some doubt over other MD5 applications as well. However, so far MD5 collision attacks have not been shown pose a threat to Digest Authentication, and the RFC 2617 allows servers to implement mechanisms to detect some collision and replay attacks.

One consequence of Digest authentication design is that the server must know the password (i.e. store it in plain text) or store the same HA1 (MD5) hash that is used to calculate the client's response (see example , below). This means that if the password database at a site is compromised the attacker will be able to impersonate any user whose access credentials are stolen. Such a compromise should not affect other sites if the MD5 hash is stored rather than the password, because the realm information is used as a salt. Unfortunately the scheme prevents use of different salts being used for each individual password held on the server.

[edit] HTTP Digest Authentication considerations

[edit] Advantages

HTTP Digest authentication is designed to be more secure than traditional digest authentication schemes; "significantly stronger than (e.g.) CRAM-MD5 ..." (RFC2617).

Some of the security strengths of HTTP Digest authentication is:

The password is not used directly in the digest, but rather HA1 = MD5(username:realm:password). This allows some implementations (e.g. JBoss DIGESTAuth) to store HA1 rather than the clear text password.
Client nonce was introduced in RFC2617, which allows the client to prevent chosen plaintext attacks (which otherwise makes e.g. rainbow tables a threat to digest authentication schemes).
Server nonce is allowed to contain timestamps. Therefore the server may inspect nonce attributes submitted by clients, to prevent replay attacks.
Server is also allowed maintain a list of recently issued or used server nonce values to prevent reuse.

[edit] Disadvantages

Digest authentication is intended as a security trade-off; it is intended to replace unencrypted HTTP Basic authentication which is extremely weak. However it is not intended to replace strong authentication protocols, such as Public key or Kerberos (protocol) authentication.

Security wise, there are few drawbacks with Digest authentication.

Much of the security options in RFC2617 is optional. If quality-of-protection (qop) is not specified by server, the client will operate in a security reduced legacy RFC2069 mode.
Digest Authentication is vulnerable to Man-in-the-middle attack; a MitM attacker could tell clients to use Basic Authentication or legacy RFC2069 Digest Authentication mode.

There is an important problem with implementing Digest Authentication in e.g. enterprise authentication. This is the requirement that either cleartext passwords or the HA1 hashes must be known in order to perform client response validation. If the authentication repository used to store passwords does not support looking up cleartext passwords or HA1 hashes, it is not possible to use HTTP Digest Authentication.

[edit] Alternative authentication protocols

Some strong authentication protocols for web based applications include:

Public key authentication (usually implemented with HTTPS / SSL Client Certificates)
Kerberos or SPNEGO authentication, primarily employed by Microsoft IIS running configured for "Integrated Windows Authentication".

Weak cleartext protocols are also in use.

Weaker Basic access authentication scheme is widely deployed.
HTML Form based authentication is also widely deployed.

The weak cleartext protocols are often used together with HTTPS network security protocols, which resolves many of the threats Digest access authentication protocol is designed to prevent.

[edit] Example with explanation

Warning: Please refer to the original specifications for a more comprehensive discussion of security issues.

The following example was originally given in RFC 2617 and is expanded here to show the full text expected for each request and response. Note that only the "auth" (authentication) quality of protection code is covered – at the time of writing only the Opera web browser is known to support "auth-int" (authentication with integrity protection). Although the specification mentions HTTP version 1.1 the scheme can be successfully added to a version 1.0 server, as shown here.

This typical transaction consists of the following steps.

The client asks for a page that requires authentication but does not provide a user name and password. Typically this is because the user simply entered the address or followed a link to the page.
The server responds with the "401" response code, providing the authentication realm and a randomly-generated, single-use value called a nonce.
At this point, the client will present the authentication realm (typically a description of the computer or system being accessed) to the user and prompt for a user name and password. The user may decide to cancel at this point.
Once a user name and password have been supplied, the client re-sends the same request but adds an authentication header that includes the response code.
In this example, the server accepts the authentication and the page is returned. If the user name is invalid and/or the password is incorrect, the server might return the "401" response code and the client would prompt the user again.

Note: A client may already have the required user name and password without needing to prompt the user, e.g. if they have previously been stored by a web browser.

Client request (no authentication):

GET /dir/index.html HTTP/1.0
Host: localhost

(followed by a new line, in the form of a carriage return followed by a line feed).

Server response:

HTTP/1.0 401 Unauthorised
Server: SokEvo/0.9
Date: Sun, 10 Apr 2005 20:26:47 GMT
WWW-Authenticate: Digest realm="testrealm@host.com",
                         qop="auth,auth-int",
                         nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093",
                         opaque="5ccc069c403ebaf9f0171e9517f40e41"
Content-Type: text/html
Content-Length: 311

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
 "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
<HTML>
  <HEAD>
    <TITLE>Error</TITLE>
    <META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=ISO-8859-1">
  </HEAD>
  <BODY><H1>401 Unauthorised.</H1></BODY>
</HTML>

Client request (user name "Mufasa", password "Circle Of Life"):

GET /dir/index.html HTTP/1.0
Host: localhost
Authorization: Digest username="Mufasa",
                      realm="testrealm@host.com",
                      nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093",
                      uri="/dir/index.html",
                      qop=auth,
                      nc=00000001,
                      cnonce="0a4f113b",
                      response="6629fae49393a05397450978507c4ef1",
                      opaque="5ccc069c403ebaf9f0171e9517f40e41"

(followed by a blank line, as before).

Server response:

HTTP/1.0 200 OK
Server: SokEvo/0.9
Date: Sun, 10 Apr 2005 20:27:03 GMT
Content-Type: text/html
Content-Length: 7984

(followed by a blank line and HTML text of the restricted page).

The "response" value is calculated in three steps, as follows. Where values are combined, they are delimited by colon symbols.

The MD5 hash of the combined user name, authentication realm and password is calculated. The result is referred to as HA1.
The MD5 hash of the combined method and digest URI is calculated, e.g. of "GET" and "/dir/index.html". The result is referred to as HA2.
The MD5 hash of the combined HA1 result, server nonce (nonce), request counter (nc), client nonce (cnonce), quality of protection code (qop) and HA2 result is calculated. The result is the "response" value provided by the client.

Since the server has the same information as the client, the response can be checked by performing the same calculation. In the example given above the result is formed as follows – where MD5() represents a function used to calculate an MD5 hash, backslashes represent a continuation and the quotes shown are not used in the calculation.

Completing the example given in RFC 2617 gives the following results for each step.

    HA1 = MD5( "Mufasa:testrealm@host.com:Circle Of Life" )
        = 939e7578ed9e3c518a452acee763bce9

    HA2 = MD5( "GET:/dir/index.html" )
        = 39aff3a2bab6126f332b942af96d3366

    Response = MD5( "939e7578ed9e3c518a452acee763bce9:\
                     dcd98b7102dd2f0e8b11d0f600bfb0c093:\
                     00000001:0a4f113b:auth:\
                     39aff3a2bab6126f332b942af96d3366" )
             = 6629fae49393a05397450978507c4ef1

At this point the client may make another request, reusing the server nonce value (the server only issues a new nonce for each "401" response) but providing a new client nonce (cnonce). For subsequent requests, the hexadecimal request counter (nc) must be greater than the last value it used – otherwise an attacker could simply "replay" an old request with the same credentials. It is up to the server to ensure that the counter increases for each of the nonce values that it has issued, rejecting any bad requests appropriately. Obviously changing the method, URI and/or counter value will result in a different response value.

The server should remember nonce values that it has recently generated. It may also remember when each nonce value was issued, expiring them after a certain amount of time. If an expired value is used, the server should respond with the "401" status code and add stale=TRUE to the authentication header – indicating that the client should re-send with the new nonce provided, without prompting the user for another user name and password.

The server does not need to keep any expired nonce values – it can simply assume that any unrecognised values have expired. It is also possible for the server to only allow each nonce value to be returned once, although this forces the client to repeat every request. Note that expiring a server nonce immediately will not work, as the client would never get a chance to use it.