Implemented SCRAM-SHA-1 for real now.

Still need to do some cleanup and polishing.
author: Remko Tronçon <git@el-tramo.be> 2009-11-21 00:59:21 (GMT)
committer: Remko Tronçon <git@el-tramo.be> 2009-11-21 01:01:05 (GMT)
commit: 2c8bfd7c49bd16bebbf0b89c01fce7817afab74f (patch)
tree: 1a7c73d4aaf81a1e243ee6f50de0385e9e6a081f
parent: fe007f1afdaf29c7ce0302da2984b5611503a822 (diff)
download: swift-2c8bfd7c49bd16bebbf0b89c01fce7817afab74f.zip
swift-2c8bfd7c49bd16bebbf0b89c01fce7817afab74f.tar.bz2
8 files changed, 87 insertions, 40 deletions
diff --git a/Swiften/Base/String.h b/Swiften/Base/String.h
index c4a44a3..0a5530c 100644
--- a/Swiften/Base/String.h
+++ b/Swiften/Base/String.h
@@ -49,75 +49,79 @@ namespace Swift {
 			bool beginsWith(char c) const { 
 				return data_.size() > 0 && data_[0] == c; 
 			}
 
 			bool beginsWith(const String& s) const {
 				return data_.substr(0, s.data_.size()) == s;
 			}
 
 			bool endsWith(char c) const { 
 				return data_.size() > 0 && data_[data_.size()-1] == c; 
 			}
 
 			String getSubstring(size_t begin, size_t end) const {
 				return String(data_.substr(begin, end));
 			}
 
 			size_t find(char c) const {
 				assert((c & 0x80) == 0);
 				return data_.find(c);
 			}
 
 			size_t npos() const {
 				return data_.npos;
 			}
 
 			friend String operator+(const String& a, const String& b) {
 				return String(a.data_ + b.data_);
 			}
 
 			friend String operator+(const String& a, char b) {
 				return String(a.data_ + b);
 			}
 
 			String& operator+=(const String& o) {
 				data_ += o.data_;
 				return *this;
 			}
 
 			String& operator+=(char c) {
 				data_ += c;
 				return *this;
 			}
 
 			String& operator=(const String& o) {
 				data_ = o.data_;
 				return *this;
 			}
 
+			char operator[](size_t i) const {
+				return data_[i];
+			}
+
 			friend bool operator>(const String& a, const String& b) {
 				return a.data_ > b.data_;
 			}
 
 			friend bool operator<(const String& a, const String& b) {
 				return a.data_ < b.data_;
 			}
 
 			friend bool operator!=(const String& a, const String& b) {
 				return a.data_ != b.data_;
 			}
 
 			friend bool operator==(const String& a, const String& b) {
 				return a.data_ == b.data_;
 			}
 
 			friend std::ostream& operator<<(std::ostream& os, const String& s) {
 				os << s.data_;
 				return os;
 			}
 
 		private:
 			std::string data_;
 	};
 }
 
 #endif
diff --git a/Swiften/Client/ClientSession.cpp b/Swiften/Client/ClientSession.cpp
index f4c4a22..fb80754 100644
--- a/Swiften/Client/ClientSession.cpp
+++ b/Swiften/Client/ClientSession.cpp
@@ -35,147 +35,148 @@ 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->onError.connect(boost::bind(&ClientSession::handleStreamError, 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::sendElement(boost::shared_ptr<Element> element) {
 	stream->writeElement(element);
 }
 
 void ClientSession::handleStreamStart(const ProtocolHeader&) {
 	checkState(WaitingForStreamStart);
 	state = Negotiating;
 }
 
 void ClientSession::handleElement(boost::shared_ptr<Element> element) {
 	if (getState() == Initialized) {
 		onElementReceived(element);
 	}
 	else if (StreamFeatures* streamFeatures = dynamic_cast<StreamFeatures*>(element.get())) {
 		if (!checkState(Negotiating)) {
 			return;
 		}
 
 		if (streamFeatures->hasStartTLS() && stream->supportsTLSEncryption()) {
 			state = WaitingForEncrypt;
 			stream->writeElement(boost::shared_ptr<StartTLSRequest>(new StartTLSRequest()));
 		}
 		else if (streamFeatures->hasAuthenticationMechanisms()) {
 			if (stream->hasTLSCertificate()) {
 				if (streamFeatures->hasAuthenticationMechanism("EXTERNAL")) {
 					state = Authenticating;
 					stream->writeElement(boost::shared_ptr<Element>(new AuthRequest("EXTERNAL", "")));
 				}
 				else {
 					finishSession(Error::TLSClientCertificateError);
 				}
 			}
-			/*else if (streamFeatures->hasAuthenticationMechanism("SCRAM-SHA-1")) {
+			else if (streamFeatures->hasAuthenticationMechanism("SCRAM-SHA-1")) {
 				// FIXME: Use a real nonce
-				authenticator = new SCRAMSHA1ClientAuthenticator(ByteArray("\x01\x02\x03\x04\x05\x06\x07\x08", 8));
+				authenticator = new SCRAMSHA1ClientAuthenticator("ClientNonce");
 				state = WaitingForCredentials;
 				onNeedCredentials();
-			}*/
+			}
 			else if (streamFeatures->hasAuthenticationMechanism("PLAIN")) {
 				authenticator = new PLAINClientAuthenticator();
 				state = WaitingForCredentials;
 				onNeedCredentials();
 			}
 			else {
 				finishSession(Error::NoSupportedAuthMechanismsError);
 			}
 		}
 		else {
 			// Start the session
 			stream->setWhitespacePingEnabled(true);
 
 			if (streamFeatures->hasSession()) {
 				needSessionStart = true;
 			}
 
 			if (streamFeatures->hasResourceBind()) {
 				state = BindingResource;
 				boost::shared_ptr<ResourceBind> resourceBind(new ResourceBind());
 				if (!localJID.getResource().isEmpty()) {
 					resourceBind->setResource(localJID.getResource());
 				}
 				stream->writeElement(IQ::createRequest(IQ::Set, JID(), "session-bind", resourceBind));
 			}
 			else if (needSessionStart) {
 				sendSessionStart();
 			}
 			else {
 				state = Initialized;
 				onInitialized();
 			}
 		}
 	}
 	else if (AuthChallenge* challenge = dynamic_cast<AuthChallenge*>(element.get())) {
 		checkState(Authenticating);
 		assert(authenticator);
 		if (authenticator->setChallenge(challenge->getValue())) {
 			stream->writeElement(boost::shared_ptr<AuthResponse>(new AuthResponse(authenticator->getResponse())));
 		}
 		else {
 			finishSession(Error::AuthenticationFailedError);
 		}
 	}
 	else if (dynamic_cast<AuthSuccess*>(element.get())) {
+		// TODO: Check success data with authenticator
 		checkState(Authenticating);
 		state = WaitingForStreamStart;
 		delete authenticator;
 		authenticator = NULL;
 		stream->resetXMPPParser();
 		sendStreamHeader();
 	}
 	else if (dynamic_cast<AuthFailure*>(element.get())) {
 		delete authenticator;
 		authenticator = NULL;
 		finishSession(Error::AuthenticationFailedError);
 	}
 	else if (dynamic_cast<TLSProceed*>(element.get())) {
 		checkState(WaitingForEncrypt);
 		state = Encrypting;
 		stream->addTLSEncryption();
 	}
 	else if (dynamic_cast<StartTLSFailure*>(element.get())) {
 		finishSession(Error::TLSError);
 	}
 	else if (IQ* iq = dynamic_cast<IQ*>(element.get())) {
 		if (state == BindingResource) {
 			boost::shared_ptr<ResourceBind> resourceBind(iq->getPayload<ResourceBind>());
 			if (iq->getType() == IQ::Error && iq->getID() == "session-bind") {
 				finishSession(Error::ResourceBindError);
 			}
 			else if (!resourceBind) {
 				finishSession(Error::UnexpectedElementError);
 			}
 			else if (iq->getType() == IQ::Result) {
 				localJID = resourceBind->getJID();
 				if (!localJID.isValid()) {
 					finishSession(Error::ResourceBindError);
 				}
 				if (needSessionStart) {
 					sendSessionStart();
 				}
 				else {
 					state = Initialized;
 				}
 			}
 			else {
 				finishSession(Error::UnexpectedElementError);
 			}
 		}
 		else if (state == StartingSession) {
 			if (iq->getType() == IQ::Result) {
 				state = Initialized;
diff --git a/Swiften/SASL/ClientAuthenticator.h b/Swiften/SASL/ClientAuthenticator.h
index f42a51e..f93f44e 100644
--- a/Swiften/SASL/ClientAuthenticator.h
+++ b/Swiften/SASL/ClientAuthenticator.h
@@ -1,43 +1,43 @@
 #pragma once
 
 #include "Swiften/Base/String.h"
 #include "Swiften/Base/ByteArray.h"
 
 namespace Swift {
 	class ClientAuthenticator {
 		public:
 			ClientAuthenticator(const String& name);
 			virtual ~ClientAuthenticator();
 
 			const String& getName() const {
 				return name;
 			}
 
 			void setCredentials(const String& authcid, const String& password, const String& authzid = String()) {
 				this->authcid = authcid;
 				this->password = password;
 				this->authzid = authzid;
 			}
 
-			virtual ByteArray getResponse() const = 0;
+			virtual ByteArray getResponse() = 0;
 			virtual bool setChallenge(const ByteArray&) = 0;
 
 			const String& getAuthenticationID() const {
 				return authcid;
 			}
 
 			const String& getAuthorizationID() const {
 				return authzid;
 			}
 
 			const String& getPassword() const {
 				return password;
 			}
 		
 		private:
 			String name;
 			String authcid;
 			String password;
 			String authzid;
 	};
 }
diff --git a/Swiften/SASL/PLAINClientAuthenticator.cpp b/Swiften/SASL/PLAINClientAuthenticator.cpp
index 8f88c3c..f61f1a0 100644
--- a/Swiften/SASL/PLAINClientAuthenticator.cpp
+++ b/Swiften/SASL/PLAINClientAuthenticator.cpp
@@ -1,16 +1,16 @@
 #include "Swiften/SASL/PLAINClientAuthenticator.h"
 
 namespace Swift {
 
 PLAINClientAuthenticator::PLAINClientAuthenticator() : ClientAuthenticator("PLAIN") {
 }
 
-ByteArray PLAINClientAuthenticator::getResponse() const {
+ByteArray PLAINClientAuthenticator::getResponse() {
 	return ByteArray(getAuthorizationID()) + '\0' + ByteArray(getAuthenticationID()) + '\0' + ByteArray(getPassword());
 }
 
 bool PLAINClientAuthenticator::setChallenge(const ByteArray&) {
 	return true;
 }
 
 }
diff --git a/Swiften/SASL/PLAINClientAuthenticator.h b/Swiften/SASL/PLAINClientAuthenticator.h
index 854eb30..bb24af7 100644
--- a/Swiften/SASL/PLAINClientAuthenticator.h
+++ b/Swiften/SASL/PLAINClientAuthenticator.h
@@ -1,13 +1,13 @@
 #pragma once
 
 #include "Swiften/SASL/ClientAuthenticator.h"
 
 namespace Swift {
 	class PLAINClientAuthenticator : public ClientAuthenticator {
 		public:
 			PLAINClientAuthenticator();
 
-			virtual ByteArray getResponse() const;
+			virtual ByteArray getResponse();
 			virtual bool setChallenge(const ByteArray&);
 	};
 }
diff --git a/Swiften/SASL/SCRAMSHA1ClientAuthenticator.cpp b/Swiften/SASL/SCRAMSHA1ClientAuthenticator.cpp
index f5c55c0..41e8f72 100644
--- a/Swiften/SASL/SCRAMSHA1ClientAuthenticator.cpp
+++ b/Swiften/SASL/SCRAMSHA1ClientAuthenticator.cpp
@@ -1,56 +1,94 @@
 #include "Swiften/SASL/SCRAMSHA1ClientAuthenticator.h"
 
 #include <cassert>
+#include <map>
+#include <boost/lexical_cast.hpp>
 
 #include "Swiften/StringCodecs/SHA1.h"
+#include "Swiften/StringCodecs/Base64.h"
 #include "Swiften/StringCodecs/HMACSHA1.h"
+#include "Swiften/StringCodecs/PBKDF2.h"
 
 namespace Swift {
 
-SCRAMSHA1ClientAuthenticator::SCRAMSHA1ClientAuthenticator(const ByteArray& nonce) : ClientAuthenticator("SCRAM-SHA-1"), step(Initial), clientnonce(nonce) {
+SCRAMSHA1ClientAuthenticator::SCRAMSHA1ClientAuthenticator(const String& nonce) : ClientAuthenticator("SCRAM-SHA-1"), step(Initial), clientnonce(nonce) {
+	// TODO: Normalize authentication id
+	// TODO: Normalize getPassword()
 }
 
-ByteArray SCRAMSHA1ClientAuthenticator::getResponse() const {
+ByteArray SCRAMSHA1ClientAuthenticator::getResponse() {
 	if (step == Initial) {
-		return getInitialClientMessage();
+		return "n,," + getInitialBareClientMessage();
 	}
 	else {
-		ByteArray mask = HMACSHA1::getResult(getClientVerifier(), initialServerMessage + getInitialClientMessage());
-		ByteArray p = SHA1::getBinaryHash(getPassword());
-		for (unsigned int i = 0; i < p.getSize(); ++i) {
-			p[i] ^= mask[i];
+		ByteArray saltedPassword = PBKDF2::encode(getPassword(), salt, iterations);
+		ByteArray clientKey = HMACSHA1::getResult(saltedPassword, "Client Key");
+		ByteArray storedKey = SHA1::getBinaryHash(clientKey);
+		ByteArray serverKey = HMACSHA1::getResult(saltedPassword, "Server Key");
+
+		ByteArray authMessage = getInitialBareClientMessage() + "," + initialServerMessage + "," + "c=biwsCg==," + "r=" + clientnonce + serverNonce;
+		ByteArray clientSignature = HMACSHA1::getResult(storedKey, authMessage);
+		serverSignature = HMACSHA1::getResult(serverKey, authMessage);
+		ByteArray clientProof = clientKey;
+		for (unsigned int i = 0; i < clientProof.getSize(); ++i) {
+			clientProof[i] ^= clientSignature[i];
 		}
-		return p;
+		ByteArray result = ByteArray("c=biwsCg==,r=") + clientnonce + serverNonce + ",p=" + Base64::encode(clientProof);
+		return result;
 	}
 }
 
-bool SCRAMSHA1ClientAuthenticator::setChallenge(const ByteArray& response) {
+bool SCRAMSHA1ClientAuthenticator::setChallenge(const ByteArray& challenge) {
 	if (step == Initial) {
-		initialServerMessage = response;
+		initialServerMessage = challenge;
+
+		// TODO: Check if these values are correct
+		std::map<char, String> keys = parseMap(String(initialServerMessage.getData(), initialServerMessage.getSize()));
+		salt = Base64::decode(keys['s']);
+		String clientServerNonce = keys['r'];
+		serverNonce = clientServerNonce.getSubstring(clientnonce.getUTF8Size(), clientServerNonce.npos());
+		iterations = boost::lexical_cast<int>(keys['i'].getUTF8String());
+
 		step = Proof;
-		return getSalt().getSize() > 0;
+		return true;
 	}
 	else {
-		return response == HMACSHA1::getResult(getClientVerifier(), getInitialClientMessage() + initialServerMessage);
+		return challenge == Base64::encode(ByteArray("v=") + Base64::encode(serverSignature));
 	}
 }
 
-ByteArray SCRAMSHA1ClientAuthenticator::getSalt() const {
-	if (initialServerMessage.getSize() < 8) {
-		std::cerr << "ERROR: SCRAM-SHA1: Invalid server response" << std::endl;
-		return ByteArray();
-	}
-	else {
-		return ByteArray(initialServerMessage.getData(), 8);
+std::map<char, String> SCRAMSHA1ClientAuthenticator::parseMap(const String& s) {
+	// TODO: Do some proper checking here
+	std::map<char, String> result;
+	if (s.getUTF8Size() > 0) {
+		char key;
+		String value;
+		size_t i = 0;
+		bool expectKey = true;
+		while (i < s.getUTF8Size()) {
+			if (expectKey) {
+				key = s[i];
+				expectKey = false;
+				i++;
+			}
+			else if (s[i] == ',') {
+				result[key] = value;
+				value = "";
+				expectKey = true;
+			}
+			else {
+				value += s[i];
+			}
+			i++;
+		}
+		result[key] = value;
 	}
+	return result;
 }
 
-ByteArray SCRAMSHA1ClientAuthenticator::getClientVerifier() const {
-	return HMACSHA1::getResult(SHA1::getBinaryHash(getPassword()), getSalt());
-}
-
-ByteArray SCRAMSHA1ClientAuthenticator::getInitialClientMessage() const {
-	return ByteArray(getAuthorizationID()) + '\0' + ByteArray(getAuthenticationID()) + '\0' + ByteArray(clientnonce);
+ByteArray SCRAMSHA1ClientAuthenticator::getInitialBareClientMessage() const {
+	// TODO: Replace , and =
+	return ByteArray(String("n=" + getAuthenticationID() + ",r=" + clientnonce));
 }
 
 }
diff --git a/Swiften/SASL/SCRAMSHA1ClientAuthenticator.h b/Swiften/SASL/SCRAMSHA1ClientAuthenticator.h
index 161afd1..ec800cc 100644
--- a/Swiften/SASL/SCRAMSHA1ClientAuthenticator.h
+++ b/Swiften/SASL/SCRAMSHA1ClientAuthenticator.h
@@ -1,31 +1,33 @@
 #pragma once
 
+#include <map>
+
 #include "Swiften/Base/String.h"
 #include "Swiften/Base/ByteArray.h"
 #include "Swiften/SASL/ClientAuthenticator.h"
 
 namespace Swift {
 	class SCRAMSHA1ClientAuthenticator : public ClientAuthenticator {
 		public:
-			SCRAMSHA1ClientAuthenticator(const ByteArray& nonce);
+			SCRAMSHA1ClientAuthenticator(const String& nonce);
 			
-			ByteArray getResponse() const;
+			ByteArray getResponse();
 			bool setChallenge(const ByteArray&);
 
 		private:
-			ByteArray getInitialClientMessage() const;
-			ByteArray getSalt() const;
-			ByteArray getClientVerifier() const;
+			ByteArray getInitialBareClientMessage() const;
+			static std::map<char, String> parseMap(const String&);
 
 		private:
 			enum Step {
 				Initial,
 				Proof
 			} step;
-			String authcid;
-			String password;
-			String authzid;
-			ByteArray clientnonce;
+			String clientnonce;
 			ByteArray initialServerMessage;
+			int iterations;
+			ByteArray serverNonce;
+			ByteArray salt;
+			ByteArray serverSignature;
 	};
 }
diff --git a/Swiften/SConscript b/Swiften/SConscript
index 4b7dc50..1ad4cb7 100644
--- a/Swiften/SConscript
+++ b/Swiften/SConscript
@@ -40,96 +40,97 @@ sources = [
 		"Queries/Responders/DiscoInfoResponder.cpp",
 		"Queries/Responders/SoftwareVersionResponder.cpp",
 		"Roster/ContactRosterItem.cpp",
 		"Roster/Roster.cpp",
 		"Roster/XMPPRoster.cpp",
 		"SASL/ClientAuthenticator.cpp",
 		"SASL/PLAINClientAuthenticator.cpp",
 		"SASL/PLAINMessage.cpp",
 		"SASL/SCRAMSHA1ClientAuthenticator.cpp",
 		"Serializer/AuthRequestSerializer.cpp",
 		"Serializer/AuthChallengeSerializer.cpp",
 		"Serializer/AuthResponseSerializer.cpp",
 		"Serializer/CompressRequestSerializer.cpp",
 		"Serializer/ElementSerializer.cpp",
 		"Serializer/MessageSerializer.cpp",
 		"Serializer/PayloadSerializer.cpp",
 		"Serializer/PayloadSerializerCollection.cpp",
 		"Serializer/PayloadSerializers/CapsInfoSerializer.cpp",
 		"Serializer/PayloadSerializers/DiscoInfoSerializer.cpp",
 		"Serializer/PayloadSerializers/ErrorSerializer.cpp",
 		"Serializer/PayloadSerializers/FullPayloadSerializerCollection.cpp",
 		"Serializer/PayloadSerializers/MUCPayloadSerializer.cpp",
 		"Serializer/PayloadSerializers/ResourceBindSerializer.cpp",
 		"Serializer/PayloadSerializers/RosterSerializer.cpp",
 		"Serializer/PayloadSerializers/SecurityLabelSerializer.cpp",
 		"Serializer/PayloadSerializers/SecurityLabelsCatalogSerializer.cpp",
 		"Serializer/PayloadSerializers/SoftwareVersionSerializer.cpp",
 		"Serializer/PayloadSerializers/VCardSerializer.cpp",
 		"Serializer/PayloadSerializers/VCardUpdateSerializer.cpp",
 		"Serializer/PayloadSerializers/StorageSerializer.cpp",
 		"Serializer/PayloadSerializers/PrivateStorageSerializer.cpp",
 		"Serializer/PresenceSerializer.cpp",
 		"Serializer/StanzaSerializer.cpp",
 		"Serializer/StreamFeaturesSerializer.cpp",
 		"Serializer/XML/XMLElement.cpp",
 		"Serializer/XML/XMLNode.cpp",
 		"Serializer/XMPPSerializer.cpp",
 		"Server/ServerFromClientSession.cpp",
 		"Server/ServerSession.cpp",
 		"Server/ServerStanzaRouter.cpp",
 		"Server/SimpleUserRegistry.cpp",
 		"Server/UserRegistry.cpp",
 		"Session/Session.cpp",
 		"Session/SessionStream.cpp",
 		"Session/BasicSessionStream.cpp",
 		"StringCodecs/Base64.cpp",
 		"StringCodecs/SHA1.cpp",
 		"StringCodecs/HMACSHA1.cpp",
+		"StringCodecs/PBKDF2.cpp",
 	]
 # "Notifier/GrowlNotifier.cpp",
 
 if myenv.get("HAVE_OPENSSL", 0) :
 	sources += ["TLS/OpenSSL/OpenSSLContext.cpp"]
 
 SConscript(dirs = [
 		"Base",
 		"Application",
 		"EventLoop",
 		"Parser",
 		"JID",
 		"Network",
 		"History",
 		"StreamStack",
 		"LinkLocal",
 		"QA",
 	])
 
 myenv.StaticLibrary("Swiften", sources + swiften_env["SWIFTEN_OBJECTS"])
 
 env.Append(UNITTEST_SOURCES = [
 		File("Application/UnitTest/ApplicationTest.cpp"),
 		File("Base/UnitTest/IDGeneratorTest.cpp"),
 		File("Base/UnitTest/StringTest.cpp"),
 		File("Base/UnitTest/ByteArrayTest.cpp"),
 		File("Client/UnitTest/ClientSessionTest.cpp"),
 		File("Compress/UnitTest/ZLibCompressorTest.cpp"),
 		File("Compress/UnitTest/ZLibDecompressorTest.cpp"),
 		File("Disco/UnitTest/CapsInfoGeneratorTest.cpp"),
 		File("Elements/UnitTest/IQTest.cpp"),
 		File("Elements/UnitTest/StanzaTest.cpp"),
 		File("Elements/UnitTest/StanzasTest.cpp"),
 		File("EventLoop/UnitTest/EventLoopTest.cpp"),
 		File("EventLoop/UnitTest/SimpleEventLoopTest.cpp"),
 		File("History/UnitTest/SQLiteHistoryManagerTest.cpp"),
 		File("JID/UnitTest/JIDTest.cpp"),
 		File("LinkLocal/UnitTest/LinkLocalConnectorTest.cpp"),
 		File("LinkLocal/UnitTest/LinkLocalServiceBrowserTest.cpp"),
 		File("LinkLocal/UnitTest/LinkLocalServiceInfoTest.cpp"),
 		File("LinkLocal/UnitTest/LinkLocalServiceTest.cpp"),
 		File("Network/UnitTest/HostAddressTest.cpp"),
 		File("Network/UnitTest/ConnectorTest.cpp"),
 		File("Parser/PayloadParsers/UnitTest/BodyParserTest.cpp"),
 		File("Parser/PayloadParsers/UnitTest/DiscoInfoParserTest.cpp"),
 		File("Parser/PayloadParsers/UnitTest/ErrorParserTest.cpp"),
 		File("Parser/PayloadParsers/UnitTest/PriorityParserTest.cpp"),
 		File("Parser/PayloadParsers/UnitTest/RawXMLPayloadParserTest.cpp"),
@@ -142,49 +143,50 @@ env.Append(UNITTEST_SOURCES = [
 		File("Parser/PayloadParsers/UnitTest/StatusShowParserTest.cpp"),
 		File("Parser/PayloadParsers/UnitTest/VCardParserTest.cpp"),
 		File("Parser/PayloadParsers/UnitTest/StorageParserTest.cpp"),
 		File("Parser/PayloadParsers/UnitTest/PrivateStorageParserTest.cpp"),
 		File("Parser/PayloadParsers/UnitTest/VCardUpdateParserTest.cpp"),
 		File("Parser/UnitTest/AttributeMapTest.cpp"),
 		File("Parser/UnitTest/IQParserTest.cpp"),
 		File("Parser/UnitTest/MessageParserTest.cpp"),
 		File("Parser/UnitTest/PayloadParserFactoryCollectionTest.cpp"),
 		File("Parser/UnitTest/PresenceParserTest.cpp"),
 		File("Parser/UnitTest/SerializingParserTest.cpp"),
 		File("Parser/UnitTest/StanzaParserTest.cpp"),
 		File("Parser/UnitTest/StreamFeaturesParserTest.cpp"),
 		File("Parser/UnitTest/XMLParserTest.cpp"),
 		File("Parser/UnitTest/XMPPParserTest.cpp"),
 		File("Presence/UnitTest/PresenceOracleTest.cpp"),
 		File("Queries/Requests/UnitTest/GetPrivateStorageRequestTest.cpp"),
 		File("Queries/Responders/UnitTest/DiscoInfoResponderTest.cpp"),
 		File("Queries/UnitTest/IQRouterTest.cpp"),
 		File("Queries/UnitTest/RequestTest.cpp"),
 		File("Queries/UnitTest/ResponderTest.cpp"),
 		File("Roster/UnitTest/OfflineRosterFilterTest.cpp"),
 		File("Roster/UnitTest/RosterTest.cpp"),
 		File("SASL/UnitTest/PLAINMessageTest.cpp"),
 		File("SASL/UnitTest/PLAINClientAuthenticatorTest.cpp"),
 		File("Serializer/PayloadSerializers/UnitTest/PayloadsSerializer.cpp"),
 		File("Serializer/PayloadSerializers/UnitTest/CapsInfoSerializerTest.cpp"),
 		File("Serializer/PayloadSerializers/UnitTest/DiscoInfoSerializerTest.cpp"),
 		File("Serializer/PayloadSerializers/UnitTest/ErrorSerializerTest.cpp"),
 		File("Serializer/PayloadSerializers/UnitTest/PrioritySerializerTest.cpp"),
 		File("Serializer/PayloadSerializers/UnitTest/ResourceBindSerializerTest.cpp"),
 		File("Serializer/PayloadSerializers/UnitTest/RosterSerializerTest.cpp"),
 		File("Serializer/PayloadSerializers/UnitTest/SecurityLabelSerializerTest.cpp"),
 		File("Serializer/PayloadSerializers/UnitTest/SecurityLabelsCatalogSerializerTest.cpp"),
 		File("Serializer/PayloadSerializers/UnitTest/SoftwareVersionSerializerTest.cpp"),
 		File("Serializer/PayloadSerializers/UnitTest/StatusSerializerTest.cpp"),
 		File("Serializer/PayloadSerializers/UnitTest/StatusShowSerializerTest.cpp"),
 		File("Serializer/PayloadSerializers/UnitTest/VCardUpdateSerializerTest.cpp"),
 		File("Serializer/PayloadSerializers/UnitTest/StorageSerializerTest.cpp"),
 		File("Serializer/PayloadSerializers/UnitTest/PrivateStorageSerializerTest.cpp"),
 		File("Serializer/UnitTest/StreamFeaturesSerializerTest.cpp"),
 		File("Serializer/XML/UnitTest/XMLElementTest.cpp"),
 		File("Server/UnitTest/ServerStanzaRouterTest.cpp"),
 		File("StreamStack/UnitTest/StreamStackTest.cpp"),
 		File("StreamStack/UnitTest/XMPPLayerTest.cpp"),
 		File("StringCodecs/UnitTest/Base64Test.cpp"),
 		File("StringCodecs/UnitTest/SHA1Test.cpp"),
 		File("StringCodecs/UnitTest/HMACSHA1Test.cpp"),
+		File("StringCodecs/UnitTest/PBKDF2Test.cpp"),
 	])
author	Remko Tronçon <git@el-tramo.be>	2009-11-21 00:59:21 (GMT)
committer	Remko Tronçon <git@el-tramo.be>	2009-11-21 01:01:05 (GMT)
commit	2c8bfd7c49bd16bebbf0b89c01fce7817afab74f (patch)
tree	1a7c73d4aaf81a1e243ee6f50de0385e9e6a081f
parent	fe007f1afdaf29c7ce0302da2984b5611503a822 (diff)
download	swift-2c8bfd7c49bd16bebbf0b89c01fce7817afab74f.zip swift-2c8bfd7c49bd16bebbf0b89c01fce7817afab74f.tar.bz2