QAuthenticatorPrivate Class Reference

#include <qauthenticator_p.h>

Public Types
enum	Method {   None, Basic, Plain, Login,   Ntlm, CramMd5, DigestMd5 }
enum	Phase { Start, Phase2, Done, Invalid }

Public Functions
QByteArray	calculateResponse (const QByteArray &method, const QByteArray &path)
QByteArray	digestMd5Response (const QByteArray &challenge, const QByteArray &method, const QByteArray &path)
void	parseHttpResponse (const QHttpResponseHeader &, bool isProxy)
void	parseHttpResponse (const QList< QPair< QByteArray, QByteArray > > &, bool isProxy)
	QAuthenticatorPrivate ()
void	updateCredentials ()
	~QAuthenticatorPrivate ()

Static Public Functions
static QAuthenticatorPrivate *	getPrivate (QAuthenticator &auth)
static const QAuthenticatorPrivate *	getPrivate (const QAuthenticator &auth)
static QHash< QByteArray, QByteArray >	parseDigestAuthenticationChallenge (const QByteArray &challenge)

Public Variables
QByteArray	challenge
QByteArray	cnonce
QString	extractedUser
bool	hasFailed
Method	method
int	nonceCount
QVariantHash	options
QString	password
Phase	phase
QString	realm
QString	user
QString	userDomain
QString	workstation

Detailed Description

Definition at line 66 of file qauthenticator_p.h.

Enumerations

Method

enum QAuthenticatorPrivate::Method

Enumerator
None
Basic
Plain
Login
Ntlm
CramMd5
DigestMd5

Definition at line 69 of file qauthenticator_p.h.

{ None, Basic, Plain, Login, Ntlm, CramMd5, DigestMd5 };

Phase

enum QAuthenticatorPrivate::Phase

Enumerator
Start
Phase2
Done
Invalid

Definition at line 82 of file qauthenticator_p.h.

               {
        Start,
        Phase2,
        Done,
        Invalid
    };

Constructors and Destructors

QAuthenticatorPrivate()

QAuthenticatorPrivate::QAuthenticatorPrivate

(

)

Definition at line 329 of file qauthenticator.cpp.

    : method(None)
    , hasFailed(false)
    , phase(Start)
    , nonceCount(0)
{
    cnonce = QCryptographicHash::hash(QByteArray::number(qrand(), 16) + QByteArray::number(qrand(), 16),
                                      QCryptographicHash::Md5).toHex();
    nonceCount = 0;
}

~QAuthenticatorPrivate()

QAuthenticatorPrivate::~QAuthenticatorPrivate

(

)

Definition at line 355 of file qauthenticator.cpp.

{
}

Functions

calculateResponse()

QByteArray QAuthenticatorPrivate::calculateResponse	(	const QByteArray &	method,
		const QByteArray &	path
	)

Definition at line 446 of file qauthenticator.cpp.

Referenced by QHttpPrivate::_q_slotSendRequest(), QHttpNetworkConnectionPrivate::createAuthorization(), and QHttpSocketEngine::slotSocketConnected().

{
    QByteArray response;
    const char *methodString = 0;
    switch(method) {
    case QAuthenticatorPrivate::None:
        methodString = "";
        phase = Done;
        break;
    case QAuthenticatorPrivate::Plain:
        response = '\0' + user.toUtf8() + '\0' + password.toUtf8();
        phase = Done;
        break;
    case QAuthenticatorPrivate::Basic:
        methodString = "Basic ";
        response = user.toLatin1() + ':' + password.toLatin1();
        response = response.toBase64();
        phase = Done;
        break;
    case QAuthenticatorPrivate::Login:
        if (challenge.contains("VXNlciBOYW1lAA==")) {
            response = user.toUtf8().toBase64();
            phase = Phase2;
        } else if (challenge.contains("UGFzc3dvcmQA")) {
            response = password.toUtf8().toBase64();
            phase = Done;
        }
        break;
    case QAuthenticatorPrivate::CramMd5:
        break;
    case QAuthenticatorPrivate::DigestMd5:
        methodString = "Digest ";
        response = digestMd5Response(challenge, requestMethod, path);
        phase = Done;
        break;
    case QAuthenticatorPrivate::Ntlm:
        methodString = "NTLM ";
        if (challenge.isEmpty()) {
            response = qNtlmPhase1().toBase64();
            if (user.isEmpty())
                phase = Done;
            else
                phase = Phase2;
        } else {
            response = qNtlmPhase3(this, QByteArray::fromBase64(challenge)).toBase64();
            phase = Done;
        }

        break;
    }
    return QByteArray(methodString) + response;
}

digestMd5Response()

QByteArray QAuthenticatorPrivate::digestMd5Response	(	const QByteArray &	challenge,
		const QByteArray &	method,
		const QByteArray &	path
	)

Definition at line 642 of file qauthenticator.cpp.

Referenced by calculateResponse().

{
    QHash<QByteArray,QByteArray> options = parseDigestAuthenticationChallenge(challenge);

    ++nonceCount;
    QByteArray nonceCountString = QByteArray::number(nonceCount, 16);
    while (nonceCountString.length() < 8)
        nonceCountString.prepend('0');

    QByteArray nonce = options.value("nonce");
    QByteArray opaque = options.value("opaque");
    QByteArray qop = options.value("qop");

//    qDebug() << "calculating digest: method=" << method << "path=" << path;
    QByteArray response = digestMd5ResponseHelper(options.value("algorithm"), user.toLatin1(),
                                              realm.toLatin1(), password.toLatin1(),
                                              nonce, nonceCountString,
                                              cnonce, qop, method,
                                              path, QByteArray());


    QByteArray credentials;
    credentials += "username=\"" + user.toLatin1() + "\", ";
    credentials += "realm=\"" + realm.toLatin1() + "\", ";
    credentials += "nonce=\"" + nonce + "\", ";
    credentials += "uri=\"" + path + "\", ";
    if (!opaque.isEmpty())
        credentials += "opaque=\"" + opaque + "\", ";
    credentials += "response=\"" + response + '\"';
    if (!options.value("algorithm").isEmpty())
        credentials += ", algorithm=" + options.value("algorithm");
    if (!options.value("qop").isEmpty()) {
        credentials += ", qop=" + qop + ", ";
        credentials += "nc=" + nonceCountString + ", ";
        credentials += "cnonce=\"" + cnonce + '\"';
    }

    return credentials;
}

getPrivate() [1/2]

static QAuthenticatorPrivate* QAuthenticatorPrivate::getPrivate ( QAuthenticator &  auth )

inlinestatic

Definition at line 100 of file qauthenticator_p.h.

Referenced by QHttpPrivate::_q_slotReadyRead(), QHttpPrivate::_q_slotSendRequest(), QHttpNetworkConnectionPrivate::createAuthorization(), QHttpNetworkConnectionChannel::ensureConnection(), QHttpNetworkConnectionPrivate::handleAuthenticateChallenge(), QNetworkAccessManagerPrivate::proxyAuthenticationRequired(), QHttpSocketEngine::slotSocketConnected(), and QHttpSocketEngine::slotSocketReadNotification().

{ return auth.d; }

getPrivate() [2/2]

static const QAuthenticatorPrivate* QAuthenticatorPrivate::getPrivate ( const QAuthenticator &  auth )

inlinestatic

Definition at line 101 of file qauthenticator_p.h.

{ return auth.d; }

parseDigestAuthenticationChallenge()

QHash< QByteArray, QByteArray > QAuthenticatorPrivate::parseDigestAuthenticationChallenge ( const QByteArray &  challenge )

static

Definition at line 502 of file qauthenticator.cpp.

Referenced by digestMd5Response(), and parseHttpResponse().

{
    QHash<QByteArray, QByteArray> options;
    // parse the challenge
    const char *d = challenge.constData();
    const char *end = d + challenge.length();
    while (d < end) {
        while (d < end && (*d == ' ' || *d == '\n' || *d == '\r'))
            ++d;
        const char *start = d;
        while (d < end && *d != '=')
            ++d;
        QByteArray key = QByteArray(start, d - start);
        ++d;
        if (d >= end)
            break;
        bool quote = (*d == '"');
        if (quote)
            ++d;
        if (d >= end)
            break;
        start = d;
        QByteArray value;
        while (d < end) {
            bool backslash = false;
            if (*d == '\\' && d < end - 1) {
                ++d;
                backslash = true;
            }
            if (!backslash) {
                if (quote) {
                    if (*d == '"')
                        break;
                } else {
                    if (*d == ',')
                        break;
                }
            }
            value += *d;
            ++d;
        }
        while (d < end && *d != ',')
            ++d;
        ++d;
        options[key] = value;
    }

    QByteArray qop = options.value("qop");
    if (!qop.isEmpty()) {
        QList<QByteArray> qopoptions = qop.split(',');
        if (!qopoptions.contains("auth"))
            return QHash<QByteArray, QByteArray>();
        // #### can't do auth-int currently
//         if (qop.contains("auth-int"))
//             qop = "auth-int";
//         else if (qop.contains("auth"))
//             qop = "auth";
//         else
//             qop = QByteArray();
        options["qop"] = "auth";
    }

    return options;
}

parseHttpResponse() [1/2]

void QAuthenticatorPrivate::parseHttpResponse	(	const QHttpResponseHeader &	header,
		bool	isProxy
	)

Definition at line 341 of file qauthenticator.cpp.

Referenced by QHttpPrivate::_q_slotReadyRead(), QHttpNetworkConnectionPrivate::handleAuthenticateChallenge(), and QHttpSocketEngine::slotSocketReadNotification().

{
    const QList<QPair<QString, QString> > values = header.values();
    QList<QPair<QByteArray, QByteArray> > rawValues;

    QList<QPair<QString, QString> >::const_iterator it, end;
    for (it = values.constBegin(), end = values.constEnd(); it != end; ++it)
        rawValues.append(qMakePair(it->first.toLatin1(), it->second.toUtf8()));

    // continue in byte array form
    parseHttpResponse(rawValues, isProxy);
}

parseHttpResponse() [2/2]

void QAuthenticatorPrivate::parseHttpResponse	(	const QList< QPair< QByteArray, QByteArray > > &	values,
		bool	isProxy
	)

Definition at line 382 of file qauthenticator.cpp.

{
    const char *search = isProxy ? "proxy-authenticate" : "www-authenticate";

    method = None;
    /*
      Fun from the HTTP 1.1 specs, that we currently ignore:

      User agents are advised to take special care in parsing the WWW-
      Authenticate field value as it might contain more than one challenge,
      or if more than one WWW-Authenticate header field is provided, the
      contents of a challenge itself can contain a comma-separated list of
      authentication parameters.
    */

    QByteArray headerVal;
    for (int i = 0; i < values.size(); ++i) {
        const QPair<QByteArray, QByteArray> &current = values.at(i);
        if (current.first.toLower() != search)
            continue;
        QByteArray str = current.second.toLower();
        if (method < Basic && str.startsWith("basic")) {
            method = Basic;
            headerVal = current.second.mid(6);
        } else if (method < Ntlm && str.startsWith("ntlm")) {
            method = Ntlm;
            headerVal = current.second.mid(5);
        } else if (method < DigestMd5 && str.startsWith("digest")) {
            method = DigestMd5;
            headerVal = current.second.mid(7);
        }
    }

    // Reparse credentials since we know the method now
    updateCredentials();
    challenge = headerVal.trimmed();
    QHash<QByteArray, QByteArray> options = parseDigestAuthenticationChallenge(challenge);

    switch(method) {
    case Basic:
        this->options[QLatin1String("realm")] = realm = QString::fromLatin1(options.value("realm"));
        if (user.isEmpty() && password.isEmpty())
            phase = Done;
        break;
    case Ntlm:
        // #### extract from header
        if (user.isEmpty() && password.isEmpty())
            phase = Done;
        break;
    case DigestMd5: {
        this->options[QLatin1String("realm")] = realm = QString::fromLatin1(options.value("realm"));
        if (options.value("stale").toLower() == "true")
            phase = Start;
        if (user.isEmpty() && password.isEmpty())
            phase = Done;
        break;
    }
    default:
        realm.clear();
        challenge = QByteArray();
        phase = Invalid;
    }
}

updateCredentials()

void QAuthenticatorPrivate::updateCredentials

(

)

Definition at line 359 of file qauthenticator.cpp.

Referenced by parseHttpResponse(), and QAuthenticator::setUser().

{
    int separatorPosn = 0;

    switch (method) {
    case QAuthenticatorPrivate::Ntlm:
        if ((separatorPosn = user.indexOf(QLatin1String("\\"))) != -1) {
            //domain name is present
            realm.clear();
            userDomain = user.left(separatorPosn);
            extractedUser = user.mid(separatorPosn + 1);
        } else {
            extractedUser = user;
            realm.clear();
            userDomain.clear();
        }
        break;
    default:
        userDomain.clear();
        break;
    }
}

Properties

challenge

QByteArray QAuthenticatorPrivate::challenge

Definition at line 79 of file qauthenticator_p.h.

Referenced by calculateResponse(), and parseHttpResponse().

cnonce

QByteArray QAuthenticatorPrivate::cnonce

Definition at line 91 of file qauthenticator_p.h.

Referenced by clientChallenge(), digestMd5Response(), and QAuthenticatorPrivate().

extractedUser

QString QAuthenticatorPrivate::extractedUser

Definition at line 74 of file qauthenticator_p.h.

Referenced by QAuthenticator::operator=(), qCreatev2Hash(), qNtlmPhase3(), and updateCredentials().

hasFailed

bool QAuthenticatorPrivate::hasFailed

Definition at line 80 of file qauthenticator_p.h.

Referenced by QHttpNetworkConnectionChannel::ensureConnection(), QHttpNetworkConnectionPrivate::handleAuthenticateChallenge(), QNetworkAccessManagerPrivate::proxyAuthenticationRequired(), and QHttpSocketEngine::slotSocketReadNotification().

method

Method QAuthenticatorPrivate::method

Definition at line 77 of file qauthenticator_p.h.

Referenced by QHttpPrivate::_q_slotSendRequest(), calculateResponse(), QHttpNetworkConnectionPrivate::createAuthorization(), digestMd5Response(), QAuthenticator::operator=(), QAuthenticator::operator==(), parseHttpResponse(), QHttpSocketEngine::slotSocketConnected(), and updateCredentials().

nonceCount

int QAuthenticatorPrivate::nonceCount

Definition at line 92 of file qauthenticator_p.h.

Referenced by digestMd5Response(), and QAuthenticatorPrivate().

options

QVariantHash QAuthenticatorPrivate::options

Definition at line 76 of file qauthenticator_p.h.

Referenced by digestMd5Response(), QAuthenticator::operator=(), QAuthenticator::operator==(), QAuthenticator::option(), QAuthenticator::options(), parseDigestAuthenticationChallenge(), parseHttpResponse(), and QAuthenticator::setOption().

password

QString QAuthenticatorPrivate::password

Definition at line 75 of file qauthenticator_p.h.

Referenced by calculateResponse(), digestMd5Response(), QAuthenticator::operator=(), QAuthenticator::operator==(), parseHttpResponse(), QAuthenticator::password(), qCreatev2Hash(), qStringFromUcs2Le(), and QAuthenticator::setPassword().

phase

Phase QAuthenticatorPrivate::phase

Definition at line 88 of file qauthenticator_p.h.

Referenced by QHttpPrivate::_q_slotReadyRead(), calculateResponse(), QAuthenticator::detach(), QHttpNetworkConnectionChannel::ensureConnection(), QHttpNetworkConnectionPrivate::handleAuthenticateChallenge(), QAuthenticator::operator=(), parseHttpResponse(), and QHttpSocketEngine::slotSocketReadNotification().

realm

QString QAuthenticatorPrivate::realm

Definition at line 78 of file qauthenticator_p.h.

Referenced by digestMd5Response(), QAuthenticator::operator=(), QAuthenticator::operator==(), parseHttpResponse(), QAuthenticator::realm(), and updateCredentials().

user

QString QAuthenticatorPrivate::user

Definition at line 73 of file qauthenticator_p.h.

Referenced by calculateResponse(), digestMd5Response(), QAuthenticator::operator=(), QAuthenticator::operator==(), parseHttpResponse(), QAuthenticator::setUser(), updateCredentials(), and QAuthenticator::user().

userDomain

QString QAuthenticatorPrivate::userDomain

Definition at line 96 of file qauthenticator_p.h.

Referenced by QAuthenticator::operator=(), qNtlmPhase3(), and updateCredentials().

workstation

QString QAuthenticatorPrivate::workstation

Definition at line 95 of file qauthenticator_p.h.

Referenced by QAuthenticator::operator=(), and qNtlmPhase3().

---

The documentation for this class was generated from the following files:

• /src/network/kernel/qauthenticator_p.h
• /src/network/kernel/qauthenticator.cpp