/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Client/ClientSession.h>

#include <boost/bind.hpp>

#include <boost/uuid/uuid.hpp>

#include <boost/uuid/uuid_io.hpp>

#include <boost/uuid/uuid_generators.hpp>

#include <boost/smart_ptr/make_shared.hpp>

#include <Swiften/Elements/ProtocolHeader.h>

#include <Swiften/Elements/StreamFeatures.h>

#include <Swiften/Elements/StreamError.h>

#include <Swiften/Elements/StartTLSRequest.h>

#include <Swiften/Elements/StartTLSFailure.h>

#include <Swiften/Elements/TLSProceed.h>

#include <Swiften/Elements/AuthRequest.h>

#include <Swiften/Elements/AuthSuccess.h>

#include <Swiften/Elements/AuthFailure.h>

#include <Swiften/Elements/AuthChallenge.h>

#include <Swiften/Elements/AuthResponse.h>

#include <Swiften/Elements/Compressed.h>

#include <Swiften/Elements/CompressFailure.h>

#include <Swiften/Elements/CompressRequest.h>

#include <Swiften/Elements/EnableStreamManagement.h>

#include <Swiften/Elements/StreamManagementEnabled.h>

#include <Swiften/Elements/StreamManagementFailed.h>

#include <Swiften/Elements/StartSession.h>

#include <Swiften/Elements/StanzaAck.h>

#include <Swiften/Elements/StanzaAckRequest.h>

#include <Swiften/Elements/IQ.h>

#include <Swiften/Elements/ResourceBind.h>

#include <Swiften/SASL/PLAINClientAuthenticator.h>

#include <Swiften/SASL/SCRAMSHA1ClientAuthenticator.h>

#include <Swiften/SASL/DIGESTMD5ClientAuthenticator.h>

#include <Swiften/Session/SessionStream.h>

#include <Swiften/TLS/CertificateTrustChecker.h>

#include <Swiften/TLS/ServerIdentityVerifier.h>

namespace Swift {

ClientSession::ClientSession(

const JID& jid,

boost::shared_ptr<SessionStream> stream) :

localJID(jid),

state(Initial),

stream(stream),

allowPLAINOverNonTLS(false),

useStreamCompression(true),

useTLS(UseTLSWhenAvailable),

useAcks(true),

needSessionStart(false),

needResourceBind(false),

needAcking(false),

rosterVersioningSupported(false),

authenticator(NULL),

certificateTrustChecker(NULL) {

}

ClientSession::~ClientSession() {

}

void ClientSession::start() {

stream->onStreamStartReceived.connect(boost::bind(&ClientSession::handleStreamStart, shared_from_this(), _1));

stream->onElementReceived.connect(boost::bind(&ClientSession::handleElement, shared_from_this(), _1));

stream->onClosed.connect(boost::bind(&ClientSession::handleStreamClosed, shared_from_this(), _1));

stream->onTLSEncrypted.connect(boost::bind(&ClientSession::handleTLSEncrypted, shared_from_this()));

assert(state == Initial);

state = WaitingForStreamStart;

sendStreamHeader();

}

void ClientSession::sendStreamHeader() {

ProtocolHeader header;

header.setTo(getRemoteJID());

stream->writeHeader(header);

}

void ClientSession::sendStanza(boost::shared_ptr<Stanza> stanza) {

stream->writeElement(stanza);

if (stanzaAckRequester_) {

stanzaAckRequester_->handleStanzaSent(stanza);

}

}

void ClientSession::handleStreamStart(const ProtocolHeader&) {

checkState(WaitingForStreamStart);

state = Negotiating;

}

void ClientSession::handleElement(boost::shared_ptr<Element> element) {

if (stream->hasTLSCertificate()) {

if (streamFeatures->hasAuthenticationMechanism("EXTERNAL")) {

state = Authenticating;

stream->writeElement(boost::make_shared<AuthRequest>("EXTERNAL", createSafeByteArray("")));

}

else {

finishSession(Error::TLSClientCertificateError);

}

}

else if (streamFeatures->hasAuthenticationMechanism("EXTERNAL")) {

state = Authenticating;

stream->writeElement(boost::make_shared<AuthRequest>("EXTERNAL", createSafeByteArray("")));

}

else if (streamFeatures->hasAuthenticationMechanism("SCRAM-SHA-1") || streamFeatures->hasAuthenticationMechanism("SCRAM-SHA-1-PLUS")) {

std::ostringstream s;

ByteArray finishMessage;

bool plus = stream->isTLSEncrypted() && streamFeatures->hasAuthenticationMechanism("SCRAM-SHA-1-PLUS");

if (plus) {

finishMessage = stream->getTLSFinishMessage();

plus &= !finishMessage.empty();

}

s << boost::uuids::random_generator()();

SCRAMSHA1ClientAuthenticator* scramAuthenticator = new SCRAMSHA1ClientAuthenticator(s.str(), plus);

if (plus) {

scramAuthenticator->setTLSChannelBindingData(finishMessage);

}

authenticator = scramAuthenticator;

state = WaitingForCredentials;

onNeedCredentials();

}

else if ((stream->isTLSEncrypted() || allowPLAINOverNonTLS) && streamFeatures->hasAuthenticationMechanism("PLAIN")) {

authenticator = new PLAINClientAuthenticator();

state = WaitingForCredentials;

onNeedCredentials();

}

std::ostringstream s;

s << boost::uuids::random_generator()();

// FIXME: Host should probably be the actual host

authenticator = new DIGESTMD5ClientAuthenticator(localJID.getDomain(), s.str());

state = WaitingForCredentials;

onNeedCredentials();

}

else {

finishSession(Error::NoSupportedAuthMechanismsError);

}

}

else {

// Start the session

rosterVersioningSupported = streamFeatures->hasRosterVersioning();

stream->setWhitespacePingEnabled(true);

needSessionStart = streamFeatures->hasSession();

needResourceBind = streamFeatures->hasResourceBind();

needAcking = streamFeatures->hasStreamManagement() && useAcks;

if (!needResourceBind) {

// Resource binding is a MUST

finishSession(Error::ResourceBindError);

}

else {

continueSessionInitialization();

}

}

}

else if (boost::dynamic_pointer_cast<Compressed>(element)) {

checkState(Compressing);

state = WaitingForStreamStart;

stream->addZLibCompression();

stream->resetXMPPParser();

sendStreamHeader();

}

else if (boost::dynamic_pointer_cast<CompressFailure>(element)) {

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/SASL/DIGESTMD5ClientAuthenticator.h>

#include <cassert>

#include <Swiften/StringCodecs/MD5.h>

#include <Swiften/StringCodecs/Hexify.h>

#include <Swiften/Base/Concat.h>

#include <Swiften/Base/Algorithm.h>

namespace Swift {

DIGESTMD5ClientAuthenticator::DIGESTMD5ClientAuthenticator(const std::string& host, const std::string& nonce) : ClientAuthenticator("DIGEST-MD5"), step(Initial), host(host), cnonce(nonce) {

}

boost::optional<SafeByteArray> DIGESTMD5ClientAuthenticator::getResponse() const {

if (step == Initial) {

return boost::optional<SafeByteArray>();

}

else if (step == Response) {

std::string realm;

if (challenge.getValue("realm")) {

realm = *challenge.getValue("realm");

}

std::string qop = "auth";

std::string digestURI = "xmpp/" + host;

std::string nc = "00000001";

// Compute the response value

ByteArray A1 = concat(

MD5::getHash(

concat(createSafeByteArray(getAuthenticationID().c_str()), createSafeByteArray(":"), createSafeByteArray(realm.c_str()), createSafeByteArray(":"), getPassword())),

createByteArray(":"), createByteArray(*challenge.getValue("nonce")), createByteArray(":"), createByteArray(cnonce));

if (!getAuthorizationID().empty()) {

append(A1, createByteArray(":" + getAuthenticationID()));

}

ByteArray A2 = createByteArray("AUTHENTICATE:" + digestURI);

std::string responseValue = Hexify::hexify(MD5::getHash(createByteArray(

Hexify::hexify(MD5::getHash(A1)) + ":"

+ *challenge.getValue("nonce") + ":" + nc + ":" + cnonce + ":" + qop + ":"

+ Hexify::hexify(MD5::getHash(A2)))));

DIGESTMD5Properties response;

response.setValue("username", getAuthenticationID());

if (!realm.empty()) {

response.setValue("realm", realm);

}

response.setValue("nonce", *challenge.getValue("nonce"));

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <map>

#include <string>

#include <vector>

#include <Swiften/SASL/ClientAuthenticator.h>

#include <Swiften/SASL/DIGESTMD5Properties.h>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

class DIGESTMD5ClientAuthenticator : public ClientAuthenticator {

public:

DIGESTMD5ClientAuthenticator(const std::string& host, const std::string& nonce);

virtual boost::optional<SafeByteArray> getResponse() const;

virtual bool setChallenge(const boost::optional<std::vector<unsigned char> >&);

private:

enum Step {

Initial,

Response,

Final,

} step;

std::string host;

std::string cnonce;

DIGESTMD5Properties challenge;

};

}

"Serializer/PayloadSerializers/StreamInitiationSerializer.cpp",

"Serializer/PayloadSerializers/BytestreamsSerializer.cpp",

"Serializer/PayloadSerializers/VCardSerializer.cpp",

"Serializer/PayloadSerializers/VCardUpdateSerializer.cpp",

"Serializer/PayloadSerializers/StorageSerializer.cpp",

"Serializer/PayloadSerializers/PrivateStorageSerializer.cpp",

"Serializer/PayloadSerializers/DelaySerializer.cpp",

"Serializer/PayloadSerializers/CommandSerializer.cpp",

"Serializer/PayloadSerializers/InBandRegistrationPayloadSerializer.cpp",

"Serializer/PayloadSerializers/SearchPayloadSerializer.cpp",

"Serializer/PayloadSerializers/FormSerializer.cpp",

"Serializer/PayloadSerializers/NicknameSerializer.cpp",

"Serializer/PayloadSerializers/JingleFileTransferDescriptionSerializer.cpp",

"Serializer/PayloadSerializers/JinglePayloadSerializer.cpp",

"Serializer/PayloadSerializers/JingleContentPayloadSerializer.cpp",

"Serializer/PayloadSerializers/JingleFileTransferHashSerializer.cpp",

"Serializer/PayloadSerializers/JingleFileTransferReceivedSerializer.cpp",

"Serializer/PayloadSerializers/JingleIBBTransportPayloadSerializer.cpp",

"Serializer/PayloadSerializers/JingleS5BTransportPayloadSerializer.cpp",

"Serializer/PayloadSerializers/StreamInitiationFileInfoSerializer.cpp",

"Serializer/PayloadSerializers/DeliveryReceiptSerializer.cpp",

"Serializer/PayloadSerializers/DeliveryReceiptRequestSerializer.cpp",

"Serializer/PresenceSerializer.cpp",

"Serializer/StanzaSerializer.cpp",

"Serializer/StreamErrorSerializer.cpp",

"Serializer/StreamFeaturesSerializer.cpp",

"Serializer/XML/XMLElement.cpp",

"Serializer/XML/XMLNode.cpp",

"Serializer/XMPPSerializer.cpp",

"Session/Session.cpp",

"Session/SessionTracer.cpp",

"Session/SessionStream.cpp",

"Session/BasicSessionStream.cpp",

"Session/BOSHSessionStream.cpp",

"StringCodecs/Base64.cpp",

"StringCodecs/SHA256.cpp",

"StringCodecs/MD5.cpp",

"StringCodecs/Hexify.cpp",

]

SConscript(dirs = [

"Avatars",

"Base",

"IDN",

"SASL",

"TLS",

"EventLoop",

"Parser",

"JID",

"Jingle",

"Disco",

"VCards",

"Network",

"Presence",

"FileTransfer",

"History",

"StreamStack",

"LinkLocal",

"StreamManagement",

"Component",

"AdHoc"

])

if env["build_examples"] :

SConscript(dirs = [

"Config",

"Examples"

])

env.SConscript(test_only = True, dirs = [

"QA",

])

myenv = swiften_env.Clone()

if myenv["PLATFORM"] != "darwin" and myenv["PLATFORM"] != "win32" and myenv.get("HAVE_GCONF", 0) :

env.MergeFlags(env["GCONF_FLAGS"])

if ARGUMENTS.get("swiften_dll", False) :

if myenv["PLATFORM"] == "posix" :

myenv.Append(LINKFLAGS = ["-Wl,-soname,libSwiften.so.$SWIFTEN_VERSION_MAJOR"])

myenv["SHLIBSUFFIX"] = ""

elif myenv["PLATFORM"] == "darwin" :

myenv.Append(LINKFLAGS = ["-Wl,-install_name,libSwiften.so.$SWIFTEN_VERSION_MAJOR", "-Wl,-compatibility_version,${SWIFTEN_VERSION_MAJOR}.${SWIFTEN_VERSION_MINOR}", "-Wl,-current_version,${SWIFTEN_VERSION_MAJOR}.${SWIFTEN_VERSION_MINOR}"])

swiften_lib = myenv.SwiftenLibrary(swiften_env["SWIFTEN_LIBRARY_FILE"], sources + swiften_env["SWIFTEN_OBJECTS"])

def symlink(env, target, source) :

if os.path.exists(str(target[0])) :

os.unlink(str(target[0]))

os.symlink(source[0].get_contents(), str(target[0]))

for alias in myenv["SWIFTEN_LIBRARY_ALIASES"] :

myenv.Command(myenv.File(alias), [myenv.Value(swiften_lib[0].name), swiften_lib[0]], symlink)

env.Append(UNITTEST_SOURCES = [

File("Avatars/UnitTest/VCardUpdateAvatarManagerTest.cpp"),

File("Avatars/UnitTest/VCardAvatarManagerTest.cpp"),

File("Avatars/UnitTest/CombinedAvatarProviderTest.cpp"),

File("Base/UnitTest/IDGeneratorTest.cpp"),

File("Base/UnitTest/SimpleIDGeneratorTest.cpp"),

File("Base/UnitTest/StringTest.cpp"),

File("Base/UnitTest/DateTimeTest.cpp"),

File("Base/UnitTest/ByteArrayTest.cpp"),

File("Chat/UnitTest/ChatStateNotifierTest.cpp"),

# File("Chat/UnitTest/ChatStateTrackerTest.cpp"),

File("Client/UnitTest/ClientSessionTest.cpp"),

File("Client/UnitTest/NickResolverTest.cpp"),

File("Compress/UnitTest/ZLibCompressorTest.cpp"),

File("Compress/UnitTest/ZLibDecompressorTest.cpp"),

File("Component/UnitTest/ComponentHandshakeGeneratorTest.cpp"),

File("Component/UnitTest/ComponentConnectorTest.cpp"),

File("Component/UnitTest/ComponentSessionTest.cpp"),

File("Disco/UnitTest/CapsInfoGeneratorTest.cpp"),

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

/*

* This implementation is shamelessly copied from L. Peter Deutsch's

* implementation, and altered to use our own defines and datastructures.

* Original license below.

*//*

Copyright (C) 1999, 2002 Aladdin Enterprises. All rights reserved.

This software is provided 'as-is', without any express or implied

warranty. In no event will the authors be held liable for any damages

arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,

including commercial applications, and to alter it and redistribute it

freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not

claim that you wrote the original software. If you use this software

in a product, an acknowledgment in the product documentation would be

appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be

misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.

L. Peter Deutsch

ghost@aladdin.com

*/

#pragma GCC diagnostic ignored "-Wold-style-cast"

#include <Swiften/StringCodecs/MD5.h>

#include <cassert>

#include <string.h>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/Base/Platform.h>

namespace Swift {

typedef unsigned char md5_byte_t; /* 8-bit byte */

typedef unsigned int md5_word_t; /* 32-bit word */

/* Define the state of the MD5 Algorithm. */

typedef struct md5_state_s {

md5_word_t count[2]; /* message length in bits, lsw first */

md5_word_t abcd[4]; /* digest buffer */

md5_byte_t buf[64]; /* accumulate block */

} md5_state_t;

#define T_MASK ((md5_word_t)~0)

#define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87)

#define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9)

#define T3 0x242070db

#define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111)

#define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050)

#define T6 0x4787c62a

#define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec)

#define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe)

#define T9 0x698098d8

#define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850)

#define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e)

#define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841)

#define T13 0x6b901122

#define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c)

#define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71)

#define T16 0x49b40821

#define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d)

#define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf)

#define T19 0x265e5a51

#define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855)

#define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2)

#define T22 0x02441453

md5_finish(&state, reinterpret_cast<md5_byte_t*>(vecptr(digest)));

return digest;

}

}

MD5::MD5() {

state = new md5_state_t;

md5_init(state);

}

MD5::~MD5() {

delete state;

}

MD5& MD5::update(const std::vector<unsigned char>& input) {

md5_append(state, reinterpret_cast<const md5_byte_t*>(vecptr(input)), input.size());

return *this;

}

std::vector<unsigned char> MD5::getHash() {

ByteArray digest;

digest.resize(16);

md5_finish(state, reinterpret_cast<md5_byte_t*>(vecptr(digest)));

return digest;

}

ByteArray MD5::getHash(const ByteArray& data) {

return getMD5Hash(data);

}

ByteArray MD5::getHash(const SafeByteArray& data) {

return getMD5Hash(data);

}

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <Swiften/Base/ByteArray.h>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

struct md5_state_s;

class MD5 {

public:

MD5();

~MD5();

MD5& update(const std::vector<unsigned char>& data);

std::vector<unsigned char> getHash();

static ByteArray getHash(const ByteArray& data);

static ByteArray getHash(const SafeByteArray& data);

private:

md5_state_s* state;

};

}

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <vector>

#include <boost/cstdint.hpp>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

class SHA1 {

public:

SHA1();

SHA1& update(const std::vector<unsigned char>& data);

std::vector<unsigned char> getHash() const;

/**

* Equivalent of:

* SHA1().update(data),getHash(), but slightly more efficient and

* convenient.

*/

static ByteArray getHash(const ByteArray& data);

static ByteArray getHash(const SafeByteArray& data);

ByteArray operator()(const SafeByteArray& data) {

return getHash(data);

}

ByteArray operator()(const ByteArray& data) {

return getHash(data);

}

private:

typedef struct {

boost::uint32_t state[5];

boost::uint32_t count[2];

boost::uint8_t buffer[64];

} CTX;

static void Init(CTX* context);

static void Transform(boost::uint32_t state[5], boost::uint8_t buffer[64]);

static void Update(CTX* context, boost::uint8_t* data, unsigned int len);

static void Final(boost::uint8_t digest[20], CTX* context);

template<typename Container> static ByteArray getHashInternal(const Container& input);

private:

CTX context;

};

}

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Base/ByteArray.h>

#include <QA/Checker/IO.h>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/StringCodecs/SHA1.h>

using namespace Swift;

class SHA1Test : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(SHA1Test);

CPPUNIT_TEST(testGetHash);

CPPUNIT_TEST(testGetHash_TwoUpdates);

CPPUNIT_TEST(testGetHash_NoData);

CPPUNIT_TEST(testGetHashStatic);

CPPUNIT_TEST(testGetHashStatic_Twice);

CPPUNIT_TEST(testGetHashStatic_NoData);

CPPUNIT_TEST_SUITE_END();

public:

void testGetHash() {

SHA1 sha;

sha.update(createByteArray("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));

CPPUNIT_ASSERT_EQUAL(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), sha.getHash());

}

void testGetHash_TwoUpdates() {

SHA1 sha;

sha.update(createByteArray("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<"));

sha.update(createByteArray("http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));

CPPUNIT_ASSERT_EQUAL(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), sha.getHash());

}

void testGetHash_TwoGetHash() {

SHA1 sha;

sha.update(createByteArray("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<http://jabber.org/protocol/disco#info<http://jabber.org/protocol/disco#items<http://jabber.org/protocol/muc<"));

sha.getHash();

CPPUNIT_ASSERT_EQUAL(createByteArray("\x42\x06\xb2\x3c\xa6\xb0\xa6\x43\xd2\x0d\x89\xb0\x4f\xf5\x8c\xf7\x8b\x80\x96\xed"), sha.getHash());

}

void testGetHash_InterleavedUpdate() {

SHA1 sha;

sha.update(createByteArray("client/pc//Exodus 0.9.1<http://jabber.org/protocol/caps<"));

sha.getHash();