summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
authorMatthias Schiffer <matthias@gamezock.de>2009-08-23 20:57:00 +0200
committerMatthias Schiffer <matthias@gamezock.de>2009-08-23 20:57:00 +0200
commit415cd36477e152c12f91a10ad61bb719373cd9d1 (patch)
tree0c235f3b1f9b844313e81eb9e900fa2662ebefcc /src
parent6666bbf908b3f2a61a9ec1959e975de54dc23b0d (diff)
downloadmad-415cd36477e152c12f91a10ad61bb719373cd9d1.tar
mad-415cd36477e152c12f91a10ad61bb719373cd9d1.zip
Authentifikation hinzugefügt.
Diffstat (limited to 'src')
-rw-r--r--src/Client/Authenticators/PasswordAuthenticator.cpp71
-rw-r--r--src/Client/Authenticators/PasswordAuthenticator.h57
-rw-r--r--src/Client/CMakeLists.txt2
-rw-r--r--src/Common/Application.cpp4
-rw-r--r--src/Common/Application.h6
-rw-r--r--src/Common/AuthBackend.h53
-rw-r--r--src/Common/AuthContext.h36
-rw-r--r--src/Common/AuthManager.cpp58
-rw-r--r--src/Common/AuthManager.h84
-rw-r--r--src/Common/CMakeLists.txt3
-rw-r--r--src/Common/Connection.h12
-rw-r--r--src/Common/Requests/AuthMethodRequest.h38
-rw-r--r--src/Common/Requests/FSInfoRequest.h2
-rw-r--r--src/Common/Requests/IdentifyRequest.h2
-rw-r--r--src/Common/Requests/StatusRequest.h2
-rw-r--r--src/Core/Exception.cpp4
-rw-r--r--src/Core/Exception.h3
-rw-r--r--src/Daemon/RequestHandlers/CommandRequestHandler.cpp1
-rw-r--r--src/Server/ConnectionManager.cpp50
-rw-r--r--src/Server/ConnectionManager.h27
-rw-r--r--src/Server/RequestHandlers/ConnectionRequestHandlerGroup.cpp45
-rw-r--r--src/Server/RequestHandlers/ConnectionRequestHandlerGroup.h2
-rw-r--r--src/Server/RequestHandlers/DaemonRequestHandlerGroup.cpp7
-rw-r--r--src/Server/RequestHandlers/DaemonRequestHandlerGroup.h2
-rw-r--r--src/mad-server.conf7
-rw-r--r--src/madc.cpp18
-rw-r--r--src/modules/AuthBackendFile/AuthBackendFile.cpp100
-rw-r--r--src/modules/AuthBackendFile/AuthBackendFile.h80
-rw-r--r--src/modules/AuthBackendFile/CMakeLists.txt8
-rw-r--r--src/modules/AuthBackendFile/Module.cpp30
-rw-r--r--src/modules/AuthBackendFile/Module.h52
-rw-r--r--src/modules/CMakeLists.txt1
-rw-r--r--src/users1
33 files changed, 812 insertions, 56 deletions
diff --git a/src/Client/Authenticators/PasswordAuthenticator.cpp b/src/Client/Authenticators/PasswordAuthenticator.cpp
new file mode 100644
index 0000000..44608db
--- /dev/null
+++ b/src/Client/Authenticators/PasswordAuthenticator.cpp
@@ -0,0 +1,71 @@
+/*
+ * PasswordAuthenticator.cpp
+ *
+ * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "PasswordAuthenticator.h"
+
+#include <Common/RequestManager.h>
+
+namespace Mad {
+namespace Client {
+namespace Authenticators {
+
+void PasswordAuthenticator::PasswordAuthRequest::sendRequest() {
+ Common::XmlPacket packet;
+ packet.setType("Authenticate");
+ packet.set("method", "Password");
+
+ packet.set("user", username);
+ std::vector<boost::uint8_t> challenge(password.begin(), password.end());
+ packet.set("challenge", challenge);
+
+ sendPacket(packet);
+}
+
+void PasswordAuthenticator::PasswordAuthRequest::handlePacket(boost::shared_ptr<const Common::XmlPacket> packet) {
+ if(packet->getType() == "Error") {
+ signalFinished(Core::Exception(packet->get<const std::string&>("Where"), static_cast<Core::Exception::ErrorCode>(packet->get<long>("ErrorCode")),
+ packet->get<long>("SubCode"), packet->get<long>("SubSubCode")));
+ return;
+ }
+ else if(packet->getType() != "OK" && packet->getType() != "Continue") {
+ signalFinished(Core::Exception(Core::Exception::UNEXPECTED_PACKET));
+ return; // TODO Logging
+ }
+
+ signalFinished(packet);
+}
+
+void PasswordAuthenticator::authenticate(Common::Application *application, Common::Connection *con, const std::string &username, const std::string &password) throw (Core::Exception) {
+ boost::shared_ptr<PasswordAuthRequest> request(new PasswordAuthRequest(application, username, password));
+
+ application->getRequestManager()->sendRequest(con, request);
+ request->wait();
+
+ std::pair<boost::shared_ptr<const Common::XmlPacket>, Core::Exception> result = request->getResult();
+
+ if(!result.first || result.second)
+ throw result.second;
+
+ if(result.first->getType() != "OK")
+ throw Core::Exception(Core::Exception::NOT_AVAILABLE);
+}
+
+}
+}
+}
diff --git a/src/Client/Authenticators/PasswordAuthenticator.h b/src/Client/Authenticators/PasswordAuthenticator.h
new file mode 100644
index 0000000..70c3cf1
--- /dev/null
+++ b/src/Client/Authenticators/PasswordAuthenticator.h
@@ -0,0 +1,57 @@
+/*
+ * PasswordAuthenticator.h
+ *
+ * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MAD_CLIENT_PASSWORDAUTHENTICATOR_H_
+#define MAD_CLIENT_PASSWORDAUTHENTICATOR_H_
+
+#include "../export.h"
+
+#include <Common/Request.h>
+
+namespace Mad {
+namespace Client {
+namespace Authenticators {
+
+class MAD_CLIENT_EXPORT PasswordAuthenticator {
+ private:
+ class MAD_CLIENT_EXPORT PasswordAuthRequest : public Common::Request {
+ private:
+ std::string username;
+ std::string password;
+
+ protected:
+ virtual void sendRequest();
+ virtual void handlePacket(boost::shared_ptr<const Common::XmlPacket> packet);
+
+ public:
+ PasswordAuthRequest(Common::Application *application, const std::string &username0, const std::string &password0)
+ : Common::Request(application), username(username0), password(password0) {}
+ };
+
+ PasswordAuthenticator();
+
+ public:
+ static void authenticate(Common::Application *application, Common::Connection *con, const std::string &username, const std::string &password) throw (Core::Exception);
+};
+
+}
+}
+}
+
+#endif /* MAD_CLIENT_PASSWORDAUTHENTICATOR_H_ */
diff --git a/src/Client/CMakeLists.txt b/src/Client/CMakeLists.txt
index 601ada8..5af7fdb 100644
--- a/src/Client/CMakeLists.txt
+++ b/src/Client/CMakeLists.txt
@@ -3,6 +3,8 @@ include_directories(${INCLUDES})
mad_library(Client
export.h
+ Authenticators/PasswordAuthenticator.h Authenticators/PasswordAuthenticator.cpp
+
Requests/DaemonCommandRequest.h Requests/DaemonCommandRequest.cpp
Requests/DaemonFSInfoRequest.h Requests/DaemonFSInfoRequest.cpp
Requests/DaemonListRequest.h
diff --git a/src/Common/Application.cpp b/src/Common/Application.cpp
index 38ef4b5..196e57a 100644
--- a/src/Common/Application.cpp
+++ b/src/Common/Application.cpp
@@ -18,6 +18,7 @@
*/
#include "Application.h"
+#include "AuthManager.h"
#include "ModuleManager.h"
#include "RequestManager.h"
#include "SystemManager.h"
@@ -26,7 +27,7 @@
namespace Mad {
namespace Common {
-Application::Application(bool server) : moduleManager(new ModuleManager(this)), requestManager(new RequestManager(this, server)),
+Application::Application(bool server) : authManager(new AuthManager), moduleManager(new ModuleManager(this)), requestManager(new RequestManager(this, server)),
systemManager(new SystemManager), userManager(new UserManager(this)) {}
Application::~Application() {
@@ -34,6 +35,7 @@ Application::~Application() {
delete systemManager;
delete requestManager;
delete moduleManager;
+ delete authManager;
}
}
diff --git a/src/Common/Application.h b/src/Common/Application.h
index 6de3b07..39cf2de 100644
--- a/src/Common/Application.h
+++ b/src/Common/Application.h
@@ -27,6 +27,7 @@
namespace Mad {
namespace Common {
+class AuthManager;
class ModuleManager;
class RequestManager;
class SystemManager;
@@ -34,6 +35,7 @@ class UserManager;
class MAD_COMMON_EXPORT Application : public Core::Application {
private:
+ AuthManager *authManager;
ModuleManager *moduleManager;
RequestManager *requestManager;
SystemManager *systemManager;
@@ -44,6 +46,10 @@ class MAD_COMMON_EXPORT Application : public Core::Application {
virtual ~Application();
public:
+ AuthManager* getAuthManager() const {
+ return authManager;
+ }
+
ModuleManager* getModuleManager() const {
return moduleManager;
}
diff --git a/src/Common/AuthBackend.h b/src/Common/AuthBackend.h
new file mode 100644
index 0000000..e933856
--- /dev/null
+++ b/src/Common/AuthBackend.h
@@ -0,0 +1,53 @@
+/*
+ * AuthBackend.h
+ *
+ * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MAD_COMMON_AUTHBACKEND_H_
+#define MAD_COMMON_AUTHBACKEND_H_
+
+#include <Core/Exception.h>
+
+#include <vector>
+
+#include <boost/cstdint.hpp>
+#include <boost/shared_ptr.hpp>
+
+namespace Mad {
+namespace Common {
+
+class AuthContext;
+class AuthManager;
+
+class AuthBackend {
+ protected:
+ friend class AuthManager;
+
+ virtual const std::vector<std::string>& getMethods() const = 0;
+
+ virtual boost::shared_ptr<AuthContext> authenticate(const std::string& /*method*/, const std::string& /*user*/,
+ const std::vector<boost::uint8_t>& /*challenge*/, std::vector<boost::uint8_t>& /*response*/,
+ boost::shared_ptr<AuthContext> /*context*/) throw(Core::Exception) = 0;
+
+ public:
+ virtual ~AuthBackend() {}
+};
+
+}
+}
+
+#endif /* MAD_COMMON_AUTHBACKEND_H_ */
diff --git a/src/Common/AuthContext.h b/src/Common/AuthContext.h
new file mode 100644
index 0000000..b402dd3
--- /dev/null
+++ b/src/Common/AuthContext.h
@@ -0,0 +1,36 @@
+/*
+ * AuthContext.h
+ *
+ * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MAD_COMMON_AUTHCONTEXT_H_
+#define MAD_COMMON_AUTHCONTEXT_H_
+
+namespace Mad {
+namespace Common {
+
+class AuthContext {
+ public:
+ virtual bool isAuthenticated() const = 0;
+
+ virtual ~AuthContext() {}
+};
+
+}
+}
+
+#endif /* MAD_COMMON_AUTHCONTEXT_H_ */
diff --git a/src/Common/AuthManager.cpp b/src/Common/AuthManager.cpp
new file mode 100644
index 0000000..b27c29f
--- /dev/null
+++ b/src/Common/AuthManager.cpp
@@ -0,0 +1,58 @@
+/*
+ * AuthManager.cpp
+ *
+ * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "AuthManager.h"
+
+#include "AuthBackend.h"
+
+namespace Mad {
+namespace Common {
+
+const std::vector<std::string> AuthManager::DenyBackend::methods;
+
+void AuthManager::registerBackend(boost::shared_ptr<AuthBackend> newBackend) {
+ boost::lock_guard<boost::shared_mutex> lock(mutex);
+
+ backend = newBackend;
+}
+
+void AuthManager::unregisterBackend(boost::shared_ptr<AuthBackend> oldBackend) {
+ boost::lock_guard<boost::shared_mutex> lock(mutex);
+
+ if(oldBackend == backend)
+ backend = denyBackend;
+}
+
+std::vector<std::string> AuthManager::getMethods() {
+ boost::shared_lock<boost::shared_mutex> lock(mutex);
+
+ return backend->getMethods();
+}
+
+boost::shared_ptr<AuthContext> AuthManager::authenticate(const std::string &method, const std::string &user, const std::vector<boost::uint8_t> &challenge,
+ std::vector<boost::uint8_t> &response, boost::shared_ptr<AuthContext> context) throw(Core::Exception) {
+ boost::lock_guard<boost::shared_mutex> lock(mutex);
+
+ response.clear();
+
+ return backend->authenticate(method, user, challenge, response, context);
+}
+
+}
+}
diff --git a/src/Common/AuthManager.h b/src/Common/AuthManager.h
new file mode 100644
index 0000000..c773214
--- /dev/null
+++ b/src/Common/AuthManager.h
@@ -0,0 +1,84 @@
+/*
+ * AuthManager.h
+ *
+ * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MAD_COMMON_AUTHMANAGER_H_
+#define MAD_COMMON_AUTHMANAGER_H_
+
+#include "export.h"
+
+#include "AuthBackend.h"
+#include "AuthContext.h"
+
+#include <Core/Exception.h>
+
+#include <vector>
+
+#include <boost/cstdint.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/shared_ptr.hpp>
+
+#include <boost/thread/shared_mutex.hpp>
+
+namespace Mad {
+namespace Common {
+
+class Application;
+
+class MAD_COMMON_EXPORT AuthManager : private boost::noncopyable {
+ private:
+ friend class Application;
+
+ class DenyBackend : public AuthBackend {
+ private:
+ const static std::vector<std::string> methods;
+
+ protected:
+ virtual const std::vector<std::string>& getMethods() const {
+ return methods;
+ }
+
+ virtual boost::shared_ptr<AuthContext> authenticate(const std::string& /*method*/, const std::string& /*user*/,
+ const std::vector<boost::uint8_t>& /*challenge*/, std::vector<boost::uint8_t>& /*response*/,
+ boost::shared_ptr<AuthContext> /*context*/) throw(Core::Exception) {
+ throw Core::Exception(Core::Exception::NOT_IMPLEMENTED);
+ }
+ };
+
+ boost::shared_ptr<DenyBackend> denyBackend;
+
+ boost::shared_ptr<AuthBackend> backend;
+
+ boost::shared_mutex mutex;
+
+ AuthManager() : denyBackend(new DenyBackend), backend(denyBackend) {}
+
+ public:
+ void registerBackend(boost::shared_ptr<AuthBackend> newBackend);
+ void unregisterBackend(boost::shared_ptr<AuthBackend> oldBackend);
+
+ std::vector<std::string> getMethods();
+
+ boost::shared_ptr<AuthContext> authenticate(const std::string &method, const std::string &user, const std::vector<boost::uint8_t> &challenge,
+ std::vector<boost::uint8_t> &response, boost::shared_ptr<AuthContext> context = boost::shared_ptr<AuthContext>()) throw(Core::Exception);
+};
+
+}
+}
+
+#endif /* MAD_COMMON_AUTHMANAGER_H_ */
diff --git a/src/Common/CMakeLists.txt b/src/Common/CMakeLists.txt
index 4ddcd07..13e1599 100644
--- a/src/Common/CMakeLists.txt
+++ b/src/Common/CMakeLists.txt
@@ -18,6 +18,9 @@ mad_library(Common
Requests/StatusRequest.h
Application.cpp Application.h
+ AuthBackend.h
+ AuthContext.h
+ AuthManager.cpp AuthManager.h
Base64Encoder.cpp Base64Encoder.h
ClientConnection.cpp ClientConnection.h
Connection.cpp Connection.h
diff --git a/src/Common/Connection.h b/src/Common/Connection.h
index e0c9ce6..bcf6c44 100644
--- a/src/Common/Connection.h
+++ b/src/Common/Connection.h
@@ -39,12 +39,10 @@ class XmlPacket;
class MAD_COMMON_EXPORT Connection : private boost::noncopyable {
private:
- bool authenticated;
-
Core::Signals::Signal2<boost::shared_ptr<const XmlPacket>, boost::uint16_t> signalReceive;
protected:
- Connection(Core::Application *application) : authenticated(0), signalReceive(application) {}
+ Connection(Core::Application *application) : signalReceive(application) {}
void receive(boost::shared_ptr<Net::Packet> packet);
@@ -66,14 +64,6 @@ class MAD_COMMON_EXPORT Connection : private boost::noncopyable {
virtual bool disconnect() = 0;
//virtual void* getCertificate(size_t *size) const = 0;
//virtual void* getPeerCertificate(size_t *size) const = 0;
-
- void setAuthenticated() {
- authenticated = true;
- }
-
- bool isAuthenticated() const {
- return authenticated;
- }
};
}
diff --git a/src/Common/Requests/AuthMethodRequest.h b/src/Common/Requests/AuthMethodRequest.h
new file mode 100644
index 0000000..e8199fd
--- /dev/null
+++ b/src/Common/Requests/AuthMethodRequest.h
@@ -0,0 +1,38 @@
+/*
+ * AuthMethodRequest.h
+ *
+ * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MAD_COMMON_REQUESTS_AUTHMETHODREQUEST_H_
+#define MAD_COMMON_REQUESTS_AUTHMETHODREQUEST_H_
+
+#include "SimpleRequest.h"
+
+namespace Mad {
+namespace Common {
+namespace Requests {
+
+class AuthMethodRequest : public SimpleRequest {
+ public:
+ AuthMethodRequest(Application *application) : SimpleRequest(application, "GetAuthMethods") {}
+};
+
+}
+}
+}
+
+#endif /* MAD_COMMON_REQUESTS_AUTHMETHODREQUEST_H_ */
diff --git a/src/Common/Requests/FSInfoRequest.h b/src/Common/Requests/FSInfoRequest.h
index 14aff57..223b7a4 100644
--- a/src/Common/Requests/FSInfoRequest.h
+++ b/src/Common/Requests/FSInfoRequest.h
@@ -20,8 +20,6 @@
#ifndef MAD_COMMON_REQUESTS_FSINFOREQUEST_H_
#define MAD_COMMON_REQUESTS_FSINFOREQUEST_H_
-#include "../export.h"
-
#include "SimpleRequest.h"
namespace Mad {
diff --git a/src/Common/Requests/IdentifyRequest.h b/src/Common/Requests/IdentifyRequest.h
index e2e1399..51b24dd 100644
--- a/src/Common/Requests/IdentifyRequest.h
+++ b/src/Common/Requests/IdentifyRequest.h
@@ -38,7 +38,7 @@ class MAD_COMMON_EXPORT IdentifyRequest : public Common::Request {
virtual void sendRequest();
public:
- IdentifyRequest(Application *application, const std::string &hostname0 = std::string()) : Request(application), hostname(hostname0) {}
+ IdentifyRequest(Application *application, const std::string &hostname0) : Request(application), hostname(hostname0) {}
};
}
diff --git a/src/Common/Requests/StatusRequest.h b/src/Common/Requests/StatusRequest.h
index 0569a72..09f4d90 100644
--- a/src/Common/Requests/StatusRequest.h
+++ b/src/Common/Requests/StatusRequest.h
@@ -20,8 +20,6 @@
#ifndef MAD_COMMON_REQUESTS_STATUSREQUEST_H_
#define MAD_COMMON_REQUESTS_STATUSREQUEST_H_
-#include "../export.h"
-
#include "SimpleRequest.h"
namespace Mad {
diff --git a/src/Core/Exception.cpp b/src/Core/Exception.cpp
index af39654..0029613 100644
--- a/src/Core/Exception.cpp
+++ b/src/Core/Exception.cpp
@@ -47,6 +47,8 @@ std::string Exception::strerror() const {
return ret + "Not found";
case INVALID_INPUT:
return ret + "Invalid input";
+ case PERMISSION:
+ return ret + "Permission denied";
case INTERNAL_ERRNO:
return ret + std::strerror(subCode);
case INVALID_ADDRESS:
@@ -57,6 +59,8 @@ std::string Exception::strerror() const {
return ret + "The daemon is unknown";
case DUPLICATE_ENTRY:
return ret + "Duplicate entry";
+ case AUTHENTICATION:
+ return ret + "Authentication failure";
default:
return ret + "Unknown error";
}
diff --git a/src/Core/Exception.h b/src/Core/Exception.h
index 15ff749..fb6fae7 100644
--- a/src/Core/Exception.h
+++ b/src/Core/Exception.h
@@ -31,11 +31,12 @@ class MAD_CORE_EXPORT Exception {
public:
enum ErrorCode {
SUCCESS = 0x0000, UNEXPECTED_PACKET = 0x0001, INVALID_ACTION = 0x0002, NOT_AVAILABLE = 0x0003, NOT_FINISHED = 0x0004, NOT_IMPLEMENTED = 0x0005,
- NOT_FOUND = 0x0006, INVALID_INPUT = 0x0007,
+ NOT_FOUND = 0x0006, INVALID_INPUT = 0x0007, PERMISSION = 0x0008,
INTERNAL_ERRNO = 0x0010,
INVALID_ADDRESS = 0x0020,
ALREADY_IDENTIFIED = 0x0030, UNKNOWN_DAEMON = 0x0031,
DUPLICATE_ENTRY = 0x0040,
+ AUTHENTICATION = 0x0050,
};
private:
diff --git a/src/Daemon/RequestHandlers/CommandRequestHandler.cpp b/src/Daemon/RequestHandlers/CommandRequestHandler.cpp
index 8ac5ec5..9be8a5b 100644
--- a/src/Daemon/RequestHandlers/CommandRequestHandler.cpp
+++ b/src/Daemon/RequestHandlers/CommandRequestHandler.cpp
@@ -26,7 +26,6 @@ namespace RequestHandlers {
void CommandRequestHandler::handleRequest(boost::shared_ptr<const Common::XmlPacket> packet, Common::XmlPacket *ret) {
// TODO Require authentication
- // TODO Error handling
std::string command = packet->get<const std::string&>("command");
diff --git a/src/Server/ConnectionManager.cpp b/src/Server/ConnectionManager.cpp
index 160f3c3..e52e8c4 100644
--- a/src/Server/ConnectionManager.cpp
+++ b/src/Server/ConnectionManager.cpp
@@ -22,6 +22,7 @@
#include "Application.h"
#include <Core/ConfigEntry.h>
#include <Core/ConfigManager.h>
+#include <Common/AuthManager.h>
#include <Common/RequestManager.h>
#include <Common/RequestHandlers/FSInfoRequestHandler.h>
#include <Common/RequestHandlers/StatusRequestHandler.h>
@@ -32,7 +33,6 @@
#include <Net/Packet.h>
#include <Net/Listener.h>
-//#include <unistd.h>
#include <algorithm>
namespace Mad {
@@ -42,8 +42,8 @@ bool ConnectionManager::ServerConnection::send(const Net::Packet &packet) {
return connection->send(packet);
}
-ConnectionManager::ServerConnection::ServerConnection(Core::Application *application, boost::shared_ptr<Net::Connection> connection0)
-: Common::Connection(application), connection(connection0), type(UNKNOWN), hostInfo(0) {
+ConnectionManager::ServerConnection::ServerConnection(Common::Application *application0, boost::shared_ptr<Net::Connection> connection0)
+: Common::Connection(application0), application(application0), connection(connection0), type(UNKNOWN), hostInfo(0) {
connection->connectSignalReceive(boost::bind(&ServerConnection::receive, this, _1));
}
@@ -57,6 +57,16 @@ bool ConnectionManager::ServerConnection::disconnect() {
return true;
}
+boost::shared_ptr<const Common::AuthContext> ConnectionManager::ServerConnection::authenticate(const std::string &method,
+ const std::string &user, const std::vector<boost::uint8_t> &challenge, std::vector<boost::uint8_t> &response) {
+ if(!isIdentified())
+ type = CLIENT;
+
+ authContext = application->getAuthManager()->authenticate(method, user, challenge, response, authContext);
+
+ return authContext;
+}
+
/*void* ConnectionManager::ServerConnection::getCertificate(size_t *size) const {
const gnutls_datum_t *cert = connection->getCertificate();
@@ -203,7 +213,6 @@ ConnectionManager::ConnectionManager(Application *application0) : application(ap
connectionRequestHandlerGroup(new RequestHandlers::ConnectionRequestHandlerGroup(application)),
daemonRequestHandlerGroup(new RequestHandlers::DaemonRequestHandlerGroup),
userRequestHandlerGroup(new RequestHandlers::UserRequestHandlerGroup(application)) {
- //requestManager->registerPacketType<RequestHandlers::GSSAPIAuthRequestHandler>("AuthGSSAPI");
application->getRequestManager()->registerPacketType<Common::RequestHandlers::FSInfoRequestHandler>("FSInfo");
application->getRequestManager()->registerPacketType<Common::RequestHandlers::StatusRequestHandler>("GetStatus");
@@ -223,12 +232,11 @@ ConnectionManager::~ConnectionManager() {
application->getRequestManager()->unregisterRequestHandlerGroup(daemonRequestHandlerGroup);
application->getRequestManager()->unregisterRequestHandlerGroup(connectionRequestHandlerGroup);
- //requestManager->unregisterPacketType("AuthGSSAPI");
application->getRequestManager()->unregisterPacketType("FSInfo");
application->getRequestManager()->unregisterPacketType("GetStatus");
}
-boost::shared_ptr<Common::Connection> ConnectionManager::getDaemonConnection(const std::string &name) const throw (Core::Exception&) {
+boost::shared_ptr<Common::Connection> ConnectionManager::getDaemonConnection(const std::string &name) const throw (Core::Exception) {
std::map<std::string, Common::HostInfo>::const_iterator hostIt = daemonInfo.find(name);
@@ -248,7 +256,7 @@ boost::shared_ptr<Common::Connection> ConnectionManager::getDaemonConnection(con
throw Core::Exception(Core::Exception::NOT_AVAILABLE);
}
-std::string ConnectionManager::getDaemonName(const Common::Connection *con) const throw (Core::Exception&) {
+std::string ConnectionManager::getDaemonName(const Common::Connection *con) const throw (Core::Exception) {
const ServerConnection *connection = dynamic_cast<const ServerConnection*>(con);
if(connection && connection->getConnectionType() == ServerConnection::DAEMON)
@@ -257,13 +265,13 @@ std::string ConnectionManager::getDaemonName(const Common::Connection *con) cons
throw Core::Exception(Core::Exception::UNKNOWN_DAEMON);
}
-void ConnectionManager::identifyDaemonConnection(Common::Connection *con, const std::string &name) throw (Core::Exception&) {
+void ConnectionManager::identifyDaemonConnection(Common::Connection *con, const std::string &name) throw (Core::Exception) {
// TODO Logging
ServerConnection *connection = dynamic_cast<ServerConnection*>(con);
if(!connection)
- throw Core::Exception(Core::Exception::INVALID_ACTION);
+ throw Core::Exception(Core::Exception::INVALID_INPUT);
if(connection->isIdentified())
throw Core::Exception(Core::Exception::ALREADY_IDENTIFIED);
@@ -283,20 +291,21 @@ void ConnectionManager::identifyDaemonConnection(Common::Connection *con, const
connection->identify(hostInfo);
updateState(hostInfo, Common::HostInfo::RUNNING);
-
- application->logf("Identified as '%s'.", name.c_str());
}
-void ConnectionManager::identifyClientConnection(Common::Connection *con) throw (Core::Exception&) {
+boost::shared_ptr<const Common::AuthContext> ConnectionManager::authenticateConnection(Common::Connection *con, const std::string &method,
+ const std::string &user, const std::vector<boost::uint8_t> &challenge, std::vector<boost::uint8_t> &response) {
+ // TODO Logging
+
ServerConnection *connection = dynamic_cast<ServerConnection*>(con);
if(!connection)
- throw Core::Exception(Core::Exception::INVALID_ACTION);
+ throw Core::Exception(Core::Exception::INVALID_INPUT);
- if(connection->isIdentified())
- throw Core::Exception(Core::Exception::ALREADY_IDENTIFIED);
+ if(!connection->isIdentified())
+ connection->identify();
- connection->identify();
+ return connection->authenticate(method, user, challenge, response);
}
std::vector<Common::HostInfo> ConnectionManager::getDaemonList() const {
@@ -309,5 +318,14 @@ std::vector<Common::HostInfo> ConnectionManager::getDaemonList() const {
return ret;
}
+bool ConnectionManager::isAuthenticated(Common::Connection *con) const {
+ ServerConnection *connection = dynamic_cast<ServerConnection*>(con);
+
+ if(!connection)
+ throw Core::Exception(Core::Exception::INVALID_INPUT);
+
+ return connection->isAuthenticated();
+}
+
}
}
diff --git a/src/Server/ConnectionManager.h b/src/Server/ConnectionManager.h
index bdf1b4d..e045a6a 100644
--- a/src/Server/ConnectionManager.h
+++ b/src/Server/ConnectionManager.h
@@ -24,6 +24,7 @@
#include <Core/Configurable.h>
#include <Core/Exception.h>
+#include <Common/AuthContext.h>
#include <Common/Connection.h>
#include <Common/HostInfo.h>
#include <Common/RequestHandlerGroup.h>
@@ -49,22 +50,25 @@ class Application;
class MAD_SERVER_EXPORT ConnectionManager : public Core::Configurable, private boost::noncopyable {
private:
- class ServerConnection : public Common::Connection {
+ class MAD_SERVER_EXPORT ServerConnection : public Common::Connection {
public:
enum ConnectionType {
UNKNOWN = 0, DAEMON, CLIENT
};
private:
+ Common::Application *application;
+
boost::shared_ptr<Net::Connection> connection;
ConnectionType type;
Common::HostInfo *hostInfo;
+ boost::shared_ptr<Common::AuthContext> authContext;
protected:
virtual bool send(const Net::Packet &packet);
public:
- ServerConnection(Core::Application *application, boost::shared_ptr<Net::Connection> connection0);
+ ServerConnection(Common::Application *application0, boost::shared_ptr<Net::Connection> connection0);
bool isConnected() const;
@@ -92,6 +96,13 @@ class MAD_SERVER_EXPORT ConnectionManager : public Core::Configurable, private b
type = DAEMON;
hostInfo = info;
}
+
+ bool isAuthenticated() const {
+ return (authContext.get() != 0 && authContext->isAuthenticated());
+ }
+
+ boost::shared_ptr<const Common::AuthContext> authenticate(const std::string &method, const std::string &user,
+ const std::vector<boost::uint8_t> &challenge, std::vector<boost::uint8_t> &response);
};
friend class Application;
@@ -126,11 +137,15 @@ class MAD_SERVER_EXPORT ConnectionManager : public Core::Configurable, private b
virtual void configFinished();
public:
- boost::shared_ptr<Common::Connection> getDaemonConnection(const std::string &name) const throw (Core::Exception&);
- std::string getDaemonName(const Common::Connection *con) const throw (Core::Exception&);
+ boost::shared_ptr<Common::Connection> getDaemonConnection(const std::string &name) const throw (Core::Exception);
+ std::string getDaemonName(const Common::Connection *con) const throw (Core::Exception);
+
+ void identifyDaemonConnection(Common::Connection *con, const std::string &name) throw (Core::Exception);
+
+ boost::shared_ptr<const Common::AuthContext> authenticateConnection(Common::Connection *con, const std::string &method,
+ const std::string &user, const std::vector<boost::uint8_t> &challenge, std::vector<boost::uint8_t> &response);
- void identifyDaemonConnection(Common::Connection *con, const std::string &name) throw (Core::Exception&);
- void identifyClientConnection(Common::Connection *con) throw (Core::Exception&);
+ bool isAuthenticated(Common::Connection *con) const;
std::vector<Common::HostInfo> getDaemonList() const;
};
diff --git a/src/Server/RequestHandlers/ConnectionRequestHandlerGroup.cpp b/src/Server/RequestHandlers/ConnectionRequestHandlerGroup.cpp
index e94853f..b59cc3d 100644
--- a/src/Server/RequestHandlers/ConnectionRequestHandlerGroup.cpp
+++ b/src/Server/RequestHandlers/ConnectionRequestHandlerGroup.cpp
@@ -21,6 +21,8 @@
#include "../Application.h"
#include "../ConnectionManager.h"
+#include <Common/AuthManager.h>
+
#include <Core/LogManager.h>
#include <boost/date_time/posix_time/posix_time.hpp>
@@ -29,9 +31,41 @@ namespace Mad {
namespace Server {
namespace RequestHandlers {
-void ConnectionRequestHandlerGroup::handleDaemonListRequest(boost::shared_ptr<const Common::XmlPacket> /*packet*/, Common::XmlPacket *ret,
+void ConnectionRequestHandlerGroup::handleAuthMethodRequest(boost::shared_ptr<const Common::XmlPacket> /*packet*/, Common::XmlPacket *ret,
Common::Connection* /*connection*/) {
- // TODO Require authentication
+ ret->setType("OK");
+
+ Common::XmlPacket::List *list = ret->createList("methods");
+
+ const std::vector<std::string> &methods = application->getAuthManager()->getMethods();
+
+ for(std::vector<std::string>::const_iterator method = methods.begin(); method != methods.end(); ++method) {
+ Common::XmlPacket::List::iterator entry = list->addEntry();
+
+ entry->set("name", *method);
+ }
+}
+
+void ConnectionRequestHandlerGroup::handleAuthRequest(boost::shared_ptr<const Common::XmlPacket> packet, Common::XmlPacket *ret, Common::Connection *connection) {
+ std::vector<boost::uint8_t> response;
+
+ boost::shared_ptr<const Common::AuthContext> authContext = application->getConnectionManager()->authenticateConnection(connection,
+ packet->get<const std::string&>("method"), packet->get<const std::string&>("user"),
+ packet->get<const std::vector<boost::uint8_t>&>("challenge"), response);
+
+ if(!response.empty())
+ ret->set("response", response);
+
+ if(authContext->isAuthenticated())
+ ret->setType("OK");
+ else
+ ret->setType("Continue");
+}
+
+void ConnectionRequestHandlerGroup::handleDaemonListRequest(boost::shared_ptr<const Common::XmlPacket> /*packet*/, Common::XmlPacket *ret,
+ Common::Connection *connection) {
+ if(!application->getConnectionManager()->isAuthenticated(connection))
+ throw(Core::Exception(Core::Exception::PERMISSION));
ret->setType("OK");
Common::XmlPacket::List *list = ret->createList("hosts");
@@ -48,10 +82,7 @@ void ConnectionRequestHandlerGroup::handleDaemonListRequest(boost::shared_ptr<co
}
void ConnectionRequestHandlerGroup::handleIdentifyRequest(boost::shared_ptr<const Common::XmlPacket> packet, Common::XmlPacket *ret, Common::Connection *connection) {
- if(packet->get<const std::string&>("hostname").empty())
- application->getConnectionManager()->identifyClientConnection(connection);
- else
- application->getConnectionManager()->identifyDaemonConnection(connection, packet->get<const std::string&>("hostname"));
+ application->getConnectionManager()->identifyDaemonConnection(connection, packet->get<const std::string&>("hostname"));
ret->setType("OK");
}
@@ -85,6 +116,8 @@ void ConnectionRequestHandlerGroup::handleLogRequest(boost::shared_ptr<const Com
}
ConnectionRequestHandlerGroup::ConnectionRequestHandlerGroup(Application *application0) : application(application0) {
+ registerHandler("GetAuthMethods", boost::bind(&ConnectionRequestHandlerGroup::handleAuthMethodRequest, this, _1, _2, _3));
+ registerHandler("Authenticate", boost::bind(&ConnectionRequestHandlerGroup::handleAuthRequest, this, _1, _2, _3));
registerHandler("ListHosts", boost::bind(&ConnectionRequestHandlerGroup::handleDaemonListRequest, this, _1, _2, _3));
registerHandler("Identify", boost::bind(&ConnectionRequestHandlerGroup::handleIdentifyRequest, this, _1, _2, _3));
registerHandler("Log", boost::bind(&ConnectionRequestHandlerGroup::handleLogRequest, this, _1, _2, _3));
diff --git a/src/Server/RequestHandlers/ConnectionRequestHandlerGroup.h b/src/Server/RequestHandlers/ConnectionRequestHandlerGroup.h
index 7f6b17c..f3d2138 100644
--- a/src/Server/RequestHandlers/ConnectionRequestHandlerGroup.h
+++ b/src/Server/RequestHandlers/ConnectionRequestHandlerGroup.h
@@ -35,6 +35,8 @@ class MAD_SERVER_EXPORT ConnectionRequestHandlerGroup : public Common::RequestHa
private:
Application *application;
+ void handleAuthMethodRequest(boost::shared_ptr<const Common::XmlPacket> packet, Common::XmlPacket *ret, Common::Connection *connection);
+ void handleAuthRequest(boost::shared_ptr<const Common::XmlPacket> packet, Common::XmlPacket *ret, Common::Connection *connection);
void handleDaemonListRequest(boost::shared_ptr<const Common::XmlPacket> packet, Common::XmlPacket *ret, Common::Connection *connection);
void handleIdentifyRequest(boost::shared_ptr<const Common::XmlPacket> packet, Common::XmlPacket *ret, Common::Connection *connection);
void handleLogRequest(boost::shared_ptr<const Common::XmlPacket> packet, Common::XmlPacket *ret, Common::Connection *connection);
diff --git a/src/Server/RequestHandlers/DaemonRequestHandlerGroup.cpp b/src/Server/RequestHandlers/DaemonRequestHandlerGroup.cpp
index 0345d7b..ee79ff2 100644
--- a/src/Server/RequestHandlers/DaemonRequestHandlerGroup.cpp
+++ b/src/Server/RequestHandlers/DaemonRequestHandlerGroup.cpp
@@ -44,10 +44,13 @@ void DaemonRequestHandlerGroup::DaemonRequestHandler::handlePacket(boost::shared
return;
}
- // TODO Require authentication
+ ConnectionManager *connectionManager = dynamic_cast<Application&>(*getApplication()).getConnectionManager();
+
+ if(!connectionManager->isAuthenticated(getConnection()))
+ throw(Core::Exception(Core::Exception::PERMISSION));
try {
- boost::shared_ptr<Common::Connection> daemonCon = dynamic_cast<Application&>(*getApplication()).getConnectionManager()->getDaemonConnection(packet->get<const std::string&>("daemon"));
+ boost::shared_ptr<Common::Connection> daemonCon = connectionManager->getDaemonConnection(packet->get<const std::string&>("daemon"));
boost::shared_ptr<Common::Request> request;
if(type == "DaemonCommand")
diff --git a/src/Server/RequestHandlers/DaemonRequestHandlerGroup.h b/src/Server/RequestHandlers/DaemonRequestHandlerGroup.h
index 086bf16..8312709 100644
--- a/src/Server/RequestHandlers/DaemonRequestHandlerGroup.h
+++ b/src/Server/RequestHandlers/DaemonRequestHandlerGroup.h
@@ -47,8 +47,6 @@ class MAD_SERVER_EXPORT DaemonRequestHandlerGroup : public Common::RequestHandle
: Common::RequestHandler(application), type(type0) {}
};
- ConnectionManager *connectionManager;
-
std::set<std::string> types;
public:
diff --git a/src/mad-server.conf b/src/mad-server.conf
index b419a42..88213e6 100644
--- a/src/mad-server.conf
+++ b/src/mad-server.conf
@@ -1,4 +1,7 @@
LoadModule "FileLogger"
+
+LoadModule "AuthBackendFile"
+
LoadModule "SystemBackendPosix"
LoadModule "SystemBackendProc"
@@ -18,6 +21,10 @@ X509TrustFile ../Cert/ca-cert.pem
X509CertFile ../Cert/cert.pem
X509KeyFile ../Cert/key.pem
+AuthBackendFile {
+ File "users"
+}
+
UserManager {
MinUid 1000
MaxUid 29999
diff --git a/src/madc.cpp b/src/madc.cpp
index c55fd3e..1fa2112 100644
--- a/src/madc.cpp
+++ b/src/madc.cpp
@@ -30,6 +30,8 @@
#include "Client/Application.h"
#include "Client/CommandParser.h"
#include "Client/InformationManager.h"
+#include "Client/PasswordReader.h"
+#include "Client/Authenticators/PasswordAuthenticator.h"
#include <iostream>
@@ -69,13 +71,19 @@ int main(int argc, char *argv[]) {
application.getRequestManager()->registerConnection(connection);
+ std::cerr << " connected." << std::endl << std::endl;
+
{
- boost::shared_ptr<Common::Requests::IdentifyRequest> request(new Common::Requests::IdentifyRequest(&application));
- application.getRequestManager()->sendRequest(connection, request);
- request->wait();
+ std::string username, password;
+
+ std::cerr << "Login: " << std::flush;
+ std::getline(std::cin, username);
+ password = Client::PasswordReader::readPassword("Password: ");
+
+ Client::Authenticators::PasswordAuthenticator::authenticate(&application, connection, username, password);
}
- std::cerr << " connected." << std::endl;
+ std::cerr << "Login successful." << std::endl << std::endl;
std::cerr << "Receiving host list..." << std::flush;
application.getInformationManager()->updateDaemonList(connection);
@@ -108,7 +116,7 @@ int main(int argc, char *argv[]) {
application.getRequestManager()->unregisterConnection(connection);
}
catch(Core::Exception &e) {
- application.logf(Core::LoggerBase::LOG_CRITICAL, "Connection error: %s", e.strerror().c_str());
+ application.logf(Core::LoggerBase::LOG_CRITICAL, "Error: %s", e.strerror().c_str());
}
delete connection;
diff --git a/src/modules/AuthBackendFile/AuthBackendFile.cpp b/src/modules/AuthBackendFile/AuthBackendFile.cpp
new file mode 100644
index 0000000..8374101
--- /dev/null
+++ b/src/modules/AuthBackendFile/AuthBackendFile.cpp
@@ -0,0 +1,100 @@
+/*
+ * AuthBackendFile.cpp
+ *
+ * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "AuthBackendFile.h"
+#include <Core/ConfigEntry.h>
+#include <Core/ConfigManager.h>
+
+#include <fstream>
+
+#include <boost/regex.hpp>
+
+namespace Mad {
+namespace Modules {
+namespace AuthBackendFile {
+
+void AuthBackendFile::readFile(const std::string &name) {
+ std::ifstream stream(name.c_str());
+ if(!stream.good()) {
+ application->logf(Core::LoggerBase::LOG_WARNING, "AuthBackendFile: Can't read file '%s'.", name.c_str());
+ return;
+ }
+
+ while(stream.good() && !stream.eof()) {
+ std::string line;
+ std::getline(stream, line);
+
+ if(line.empty())
+ continue;
+
+ static const boost::regex regex("([^:]+):(.+)", boost::regex_constants::perl);
+ boost::smatch match;
+
+ if(!boost::regex_match(line, match, regex)) {
+ application->logf(Core::LoggerBase::LOG_WARNING, "AuthBackendFile: Malformed line in file '%s'.", name.c_str());
+ continue;
+ }
+
+
+ userMap.insert(std::make_pair(match[1].str(), match[2].str()));
+ }
+}
+
+bool AuthBackendFile::handleConfigEntry(const Core::ConfigEntry &entry, bool /*handled*/) {
+ if(!entry[0].getKey().matches("AuthBackendFile"))
+ return false;
+
+ if(entry[1].empty())
+ return true;
+
+ if(entry[1].getKey().matches("File")) {
+ if(entry[2].empty()) {
+ readFile(entry[1][0]);
+ }
+ }
+ else if(!entry[2].empty())
+ return false;
+
+ return true;
+}
+
+boost::shared_ptr<Common::AuthContext> AuthBackendFile::authenticate(const std::string &method, const std::string &user,
+ const std::vector<boost::uint8_t> &challenge, std::vector<boost::uint8_t>& /*response*/,
+ boost::shared_ptr<Common::AuthContext> context) throw(Core::Exception) {
+ if(method != "Password")
+ throw(Core::Exception(Core::Exception::INVALID_INPUT));
+
+ if(context.get() != 0 && dynamic_cast<AuthContextFile*>(context.get()) == 0)
+ throw(Core::Exception(Core::Exception::INVALID_INPUT));
+
+ if(context.get() == 0)
+ context.reset(new AuthContextFile);
+
+ std::string password(challenge.begin(), challenge.end());
+
+ std::map<std::string, std::string>::iterator userIt = userMap.find(user);
+ if(userIt == userMap.end() || password != userIt->second)
+ throw(Core::Exception(Core::Exception::AUTHENTICATION));
+
+ return context;
+}
+
+}
+}
+}
diff --git a/src/modules/AuthBackendFile/AuthBackendFile.h b/src/modules/AuthBackendFile/AuthBackendFile.h
new file mode 100644
index 0000000..81e7d12
--- /dev/null
+++ b/src/modules/AuthBackendFile/AuthBackendFile.h
@@ -0,0 +1,80 @@
+/*
+ * AuthBackendFile.h
+ *
+ * Copyright (C) 2008 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MAD_MODULES_AUTHBACKENDFILE_AUTHBACKENDFILE_H_
+#define MAD_MODULES_AUTHBACKENDFILE_AUTHBACKENDFILE_H_
+
+#include "../export.h"
+
+#include <Common/AuthBackend.h>
+#include <Common/AuthContext.h>
+#include <Common/Application.h>
+
+#include <Core/Configurable.h>
+#include <Core/ConfigManager.h>
+
+namespace Mad {
+namespace Modules {
+namespace AuthBackendFile {
+
+class MAD_MODULE_EXPORT AuthBackendFile : public Common::AuthBackend, private Core::Configurable, private boost::noncopyable {
+ private:
+ class AuthContextFile : public Common::AuthContext {
+ protected:
+ virtual bool isAuthenticated() const {
+ return true;
+ }
+ };
+
+ void readFile(const std::string &name);
+
+ std::vector<std::string> methods;
+
+ Common::Application *application;
+
+ std::map<std::string, std::string> userMap;
+
+ protected:
+ virtual bool handleConfigEntry(const Core::ConfigEntry &entry, bool /*handled*/);
+
+ virtual const std::vector<std::string>& getMethods() const {
+ return methods;
+ }
+
+ virtual boost::shared_ptr<Common::AuthContext> authenticate(const std::string &method, const std::string &user,
+ const std::vector<boost::uint8_t> &challenge, std::vector<boost::uint8_t> &response,
+ boost::shared_ptr<Common::AuthContext> context) throw(Core::Exception);
+
+ public:
+ AuthBackendFile(Common::Application *application0) : application(application0) {
+ methods.push_back("Password");
+
+ application->getConfigManager()->registerConfigurable(this);
+ }
+
+ virtual ~AuthBackendFile() {
+ application->getConfigManager()->unregisterConfigurable(this);
+ }
+};
+
+}
+}
+}
+
+#endif /* MAD_MODULES_AUTHBACKENDFILE_AUTHBACKENDFILE_H_ */
diff --git a/src/modules/AuthBackendFile/CMakeLists.txt b/src/modules/AuthBackendFile/CMakeLists.txt
new file mode 100644
index 0000000..3afd71f
--- /dev/null
+++ b/src/modules/AuthBackendFile/CMakeLists.txt
@@ -0,0 +1,8 @@
+include_directories(${INCLUDES})
+
+mad_module(AuthBackendFile
+ Module.cpp Module.h
+ AuthBackendFile.cpp AuthBackendFile.h
+)
+
+mad_module_libraries(AuthBackendFile)
diff --git a/src/modules/AuthBackendFile/Module.cpp b/src/modules/AuthBackendFile/Module.cpp
new file mode 100644
index 0000000..e5a9a18
--- /dev/null
+++ b/src/modules/AuthBackendFile/Module.cpp
@@ -0,0 +1,30 @@
+/*
+ * Module.cpp
+ *
+ * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "../export.h"
+
+#include "Module.h"
+
+extern "C" {
+
+MAD_MODULE_EXPORT Mad::Common::Module* AuthBackendFile_create(Mad::Common::Application *application) {
+ return new Mad::Modules::AuthBackendFile::Module(application);
+}
+
+}
diff --git a/src/modules/AuthBackendFile/Module.h b/src/modules/AuthBackendFile/Module.h
new file mode 100644
index 0000000..b0d14aa
--- /dev/null
+++ b/src/modules/AuthBackendFile/Module.h
@@ -0,0 +1,52 @@
+/*
+ * Module.h
+ *
+ * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MAD_MODULES_AUTHBACKENDFILE_MODULE_H_
+#define MAD_MODULES_AUTHBACKENDFILE_MODULE_H_
+
+#include "AuthBackendFile.h"
+
+#include <Common/Module.h>
+#include <Common/AuthManager.h>
+
+namespace Mad {
+namespace Modules {
+namespace AuthBackendFile {
+
+class Module : public Common::Module {
+ private:
+ Common::Application *application;
+
+ boost::shared_ptr<AuthBackendFile> backend;
+
+ public:
+ Module(Common::Application *application0) : application(application0), backend(new AuthBackendFile(application)) {
+ application->getAuthManager()->registerBackend(backend);
+ }
+
+ virtual ~Module() {
+ application->getAuthManager()->unregisterBackend(backend);
+ }
+};
+
+}
+}
+}
+
+#endif /* MAD_MODULES_AUTHBACKENDFILE_MODULE_H_ */
diff --git a/src/modules/CMakeLists.txt b/src/modules/CMakeLists.txt
index 7e11214..e5890f4 100644
--- a/src/modules/CMakeLists.txt
+++ b/src/modules/CMakeLists.txt
@@ -33,6 +33,7 @@ macro(mad_module_libraries name)
endif(WITH_${upper_name})
endmacro(mad_module_libraries)
+add_subdirectory(AuthBackendFile)
add_subdirectory(FileLogger)
if(UNIX)
diff --git a/src/users b/src/users
new file mode 100644
index 0000000..93dc7d2
--- /dev/null
+++ b/src/users
@@ -0,0 +1 @@
+root:admin