X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fmodules%2Fm_sasl.cpp;h=02a302c11cacd46d1d660a792745fcffc9efdf04;hb=f9fd78c01623514a060c607534fc52cb73140200;hp=7867c245d3520329943a4cf2b3ac84f1db1a0201;hpb=2630a87bb13b089e6d0fdcff4bcd0f3a9612e52f;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_sasl.cpp b/src/modules/m_sasl.cpp index 7867c245d..02a302c11 100644 --- a/src/modules/m_sasl.cpp +++ b/src/modules/m_sasl.cpp @@ -1,33 +1,152 @@ -/* +------------------------------------+ - * | Inspire Internet Relay Chat Daemon | - * +------------------------------------+ +/* + * InspIRCd -- Internet Relay Chat Daemon * - * InspIRCd: (C) 2002-2009 InspIRCd Development Team - * See: http://wiki.inspircd.org/Credits + * Copyright (C) 2009-2010 Daniel De Graaf + * Copyright (C) 2008 Craig Edwards * - * This program is free but copyrighted software; see - * the file COPYING for details. + * This file is part of InspIRCd. InspIRCd is free software: you can + * redistribute it and/or modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation, version 2. * - * --------------------------------------------------- + * 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 General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . */ + #include "inspircd.h" -#include "m_cap.h" -#include "account.h" +#include "modules/cap.h" +#include "modules/account.h" +#include "modules/sasl.h" +#include "modules/ssl.h" +#include "modules/spanningtree.h" + +static std::string sasl_target; + +class ServerTracker : public SpanningTreeEventListener +{ + bool online; + + void Update(const Server* server, bool linked) + { + if (sasl_target == "*") + return; + + if (InspIRCd::Match(server->GetName(), sasl_target)) + { + ServerInstance->Logs->Log(MODNAME, LOG_VERBOSE, "SASL target server \"%s\" %s", sasl_target.c_str(), (linked ? "came online" : "went offline")); + online = linked; + } + } + + void OnServerLink(const Server* server) CXX11_OVERRIDE + { + Update(server, true); + } -/* $ModDesc: Provides support for IRC Authentication Layer (aka: atheme SASL) via AUTHENTICATE. */ + void OnServerSplit(const Server* server) CXX11_OVERRIDE + { + Update(server, false); + } + + public: + ServerTracker(Module* mod) + : SpanningTreeEventListener(mod) + { + Reset(); + } + + void Reset() + { + if (sasl_target == "*") + { + online = true; + return; + } + + online = false; + + ProtocolInterface::ServerList servers; + ServerInstance->PI->GetServerList(servers); + for (ProtocolInterface::ServerList::const_iterator i = servers.begin(); i != servers.end(); ++i) + { + const ProtocolInterface::ServerInfo& server = *i; + if (InspIRCd::Match(server.servername, sasl_target)) + { + online = true; + break; + } + } + } + + bool IsOnline() const { return online; } +}; + +class SASLCap : public Cap::Capability +{ + std::string mechlist; + const ServerTracker& servertracker; + + bool OnRequest(LocalUser* user, bool adding) CXX11_OVERRIDE + { + // Requesting this cap is allowed anytime + if (adding) + return true; + + // But removing it can only be done when unregistered + return (user->registered != REG_ALL); + } + + bool OnList(LocalUser* user) CXX11_OVERRIDE + { + return servertracker.IsOnline(); + } + + const std::string* GetValue(LocalUser* user) const CXX11_OVERRIDE + { + return &mechlist; + } + + public: + SASLCap(Module* mod, const ServerTracker& tracker) + : Cap::Capability(mod, "sasl") + , servertracker(tracker) + { + } + + void SetMechlist(const std::string& newmechlist) + { + if (mechlist == newmechlist) + return; + + mechlist = newmechlist; + NotifyValueChange(); + } +}; enum SaslState { SASL_INIT, SASL_COMM, SASL_DONE }; enum SaslResult { SASL_OK, SASL_FAIL, SASL_ABORT }; +static Events::ModuleEventProvider* saslevprov; + +static void SendSASL(const parameterlist& params) +{ + if (!ServerInstance->PI->SendEncapsulatedData(sasl_target, "SASL", params)) + { + FOREACH_MOD_CUSTOM(*saslevprov, SASLEventListener, OnSASLAuth, (params)); + } +} + /** * Tracks SASL authentication state like charybdis does. --nenolod */ -class SaslAuthenticator : public classbase +class SaslAuthenticator { private: - InspIRCd *ServerInstance; - Module *Creator; std::string agent; User *user; SaslState state; @@ -35,23 +154,28 @@ class SaslAuthenticator : public classbase bool state_announced; public: - SaslAuthenticator(User *user_, std::string method, InspIRCd *instance, Module *ctor) - : ServerInstance(instance), Creator(ctor), user(user_), state(SASL_INIT), state_announced(false) + SaslAuthenticator(User* user_, const std::string& method) + : user(user_), state(SASL_INIT), state_announced(false) { - this->user->Extend("sasl_authenticator", this); - - std::deque params; - params.push_back("*"); - params.push_back("SASL"); + parameterlist params; params.push_back(user->uuid); params.push_back("*"); params.push_back("S"); params.push_back(method); - ServerInstance->PI->SendEncapsulatedData(params); + LocalUser* localuser = IS_LOCAL(user); + if (method == "EXTERNAL" && localuser) + { + std::string fp = SSLClientCert::GetFingerprint(&localuser->eh); + + if (fp.size()) + params.push_back(fp); + } + + SendSASL(params); } - SaslResult GetSaslResult(std::string &result_) + SaslResult GetSaslResult(const std::string &result_) { if (result_ == "F") return SASL_FAIL; @@ -63,32 +187,38 @@ class SaslAuthenticator : public classbase } /* checks for and deals with a state change. */ - SaslState ProcessInboundMessage(std::deque &msg) + SaslState ProcessInboundMessage(const std::vector &msg) { switch (this->state) { case SASL_INIT: - this->agent = msg[2]; - this->user->Write("AUTHENTICATE %s", msg[5].c_str()); + this->agent = msg[0]; this->state = SASL_COMM; - break; + /* fall through */ case SASL_COMM: - if (msg[2] != this->agent) + if (msg[0] != this->agent) return this->state; - if (msg[4] != "D") - this->user->Write("AUTHENTICATE %s", msg[5].c_str()); - else + if (msg.size() < 4) + return this->state; + + if (msg[2] == "C") + this->user->Write("AUTHENTICATE %s", msg[3].c_str()); + else if (msg[2] == "D") { this->state = SASL_DONE; - this->result = this->GetSaslResult(msg[5]); + this->result = this->GetSaslResult(msg[3]); } + else if (msg[2] == "M") + this->user->WriteNumeric(908, msg[3], "are available SASL mechanisms"); + else + ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "Services sent an unknown SASL message \"%s\" \"%s\"", msg[2].c_str(), msg[3].c_str()); break; case SASL_DONE: break; default: - ServerInstance->Logs->Log("m_sasl", DEFAULT, "WTF: SaslState is not a known state (%d)", this->state); + ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "WTF: SaslState is not a known state (%d)", this->state); break; } @@ -106,16 +236,14 @@ class SaslAuthenticator : public classbase if (this->state != SASL_COMM) return true; - std::deque params; - params.push_back("*"); - params.push_back("SASL"); + parameterlist params; params.push_back(this->user->uuid); params.push_back(this->agent); params.push_back("C"); params.insert(params.end(), parameters.begin(), parameters.end()); - ServerInstance->PI->SendEncapsulatedData(params); + SendSASL(params); if (parameters[0][0] == '*') { @@ -134,13 +262,13 @@ class SaslAuthenticator : public classbase switch (this->result) { case SASL_OK: - this->user->WriteNumeric(903, "%s :SASL authentication successful", this->user->nick.c_str()); + this->user->WriteNumeric(903, "SASL authentication successful"); break; case SASL_ABORT: - this->user->WriteNumeric(906, "%s :SASL authentication aborted", this->user->nick.c_str()); + this->user->WriteNumeric(906, "SASL authentication aborted"); break; case SASL_FAIL: - this->user->WriteNumeric(904, "%s :SASL authentication failed", this->user->nick.c_str()); + this->user->WriteNumeric(904, "SASL authentication failed"); break; default: break; @@ -148,139 +276,129 @@ class SaslAuthenticator : public classbase this->state_announced = true; } - - ~SaslAuthenticator() - { - this->user->Shrink("sasl_authenticator"); - this->AnnounceState(); - } }; class CommandAuthenticate : public Command { - Module* Creator; public: - CommandAuthenticate (InspIRCd* Instance, Module* creator) : Command(Instance,"AUTHENTICATE", 0, 1, true), Creator(creator) + SimpleExtItem& authExt; + Cap::Capability& cap; + CommandAuthenticate(Module* Creator, SimpleExtItem& ext, Cap::Capability& Cap) + : Command(Creator, "AUTHENTICATE", 1), authExt(ext), cap(Cap) { - this->source = "m_sasl.so"; + works_before_reg = true; } CmdResult Handle (const std::vector& parameters, User *user) { - /* Only allow AUTHENTICATE on unregistered clients */ - if (user->registered != REG_ALL) { - if (!user->GetExt("sasl")) + if (!cap.get(user)) return CMD_FAILURE; - SaslAuthenticator *sasl; - if (!(user->GetExt("sasl_authenticator", sasl))) - sasl = new SaslAuthenticator(user, parameters[0], ServerInstance, Creator); + SaslAuthenticator *sasl = authExt.get(user); + if (!sasl) + authExt.set(user, new SaslAuthenticator(user, parameters[0])); else if (sasl->SendClientMessage(parameters) == false) // IAL abort extension --nenolod - delete sasl; + { + sasl->AnnounceState(); + authExt.unset(user); + } } return CMD_FAILURE; } }; - -class ModuleSASL : public Module +class CommandSASL : public Command { - CommandAuthenticate sasl; public: - - ModuleSASL(InspIRCd* Me) - : Module(Me), sasl(Me, this) + SimpleExtItem& authExt; + CommandSASL(Module* Creator, SimpleExtItem& ext) : Command(Creator, "SASL", 2), authExt(ext) { - Implementation eventlist[] = { I_OnEvent, I_OnUserRegister, I_OnPostConnect, I_OnUserDisconnect, I_OnCleanup }; - ServerInstance->Modules->Attach(eventlist, this, 5); - - ServerInstance->AddCommand(&sasl); - - if (!ServerInstance->Modules->Find("m_services_account.so") || !ServerInstance->Modules->Find("m_cap.so")) - ServerInstance->Logs->Log("m_sasl", DEFAULT, "WARNING: m_services_account.so and m_cap.so are not loaded! m_sasl.so will NOT function correctly until these two modules are loaded!"); + this->flags_needed = FLAG_SERVERONLY; // should not be called by users } - virtual int OnUserRegister(User *user) + CmdResult Handle(const std::vector& parameters, User *user) { - SaslAuthenticator *sasl_; - if (user->GetExt("sasl_authenticator", sasl_)) + User* target = ServerInstance->FindUUID(parameters[1]); + if (!target) { - sasl_->Abort(); - delete sasl_; - user->Shrink("sasl_authenticator"); + ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "User not found in sasl ENCAP event: %s", parameters[1].c_str()); + return CMD_FAILURE; } - return 0; - } + SaslAuthenticator *sasl = authExt.get(target); + if (!sasl) + return CMD_FAILURE; - virtual void OnCleanup(int target_type, void *item) - { - if (target_type == TYPE_USER) - OnUserDisconnect((User*)item); - } - - virtual void OnUserDisconnect(User *user) - { - SaslAuthenticator *sasl_; - if (user->GetExt("sasl_authenticator", sasl_)) + SaslState state = sasl->ProcessInboundMessage(parameters); + if (state == SASL_DONE) { - delete sasl_; - user->Shrink("sasl_authenticator"); + sasl->AnnounceState(); + authExt.unset(target); } + return CMD_SUCCESS; } - virtual void OnPostConnect(User* user) + RouteDescriptor GetRouting(User* user, const std::vector& parameters) { - if (!IS_LOCAL(user)) - return; - - std::string* str = NULL; + return ROUTE_BROADCAST; + } +}; - if (user->GetExt("accountname", str)) - ServerInstance->PI->SendMetaData(user, TYPE_USER, "accountname", *str); +class ModuleSASL : public Module +{ + SimpleExtItem authExt; + ServerTracker servertracker; + SASLCap cap; + CommandAuthenticate auth; + CommandSASL sasl; + Events::ModuleEventProvider sasleventprov; - return; + public: + ModuleSASL() + : authExt("sasl_auth", ExtensionItem::EXT_USER, this) + , servertracker(this) + , cap(this, servertracker) + , auth(this, authExt, cap) + , sasl(this, authExt) + , sasleventprov(this, "event/sasl") + { + saslevprov = &sasleventprov; } - virtual ~ModuleSASL() + void init() CXX11_OVERRIDE { + if (!ServerInstance->Modules->Find("m_services_account.so") || !ServerInstance->Modules->Find("m_cap.so")) + ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "WARNING: m_services_account.so and m_cap.so are not loaded! m_sasl.so will NOT function correctly until these two modules are loaded!"); } - virtual Version GetVersion() + void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE { - return Version("$Id$",VF_VENDOR,API_VERSION); + sasl_target = ServerInstance->Config->ConfValue("sasl")->getString("target", "*"); + servertracker.Reset(); } - virtual void OnEvent(Event *ev) + ModResult OnUserRegister(LocalUser *user) CXX11_OVERRIDE { - GenericCapHandler(ev, "sasl", "sasl"); - - if (ev->GetEventID() == "encap_received") + SaslAuthenticator *sasl_ = authExt.get(user); + if (sasl_) { - std::deque* parameters = (std::deque*)ev->GetData(); - - if ((*parameters)[1] != "SASL") - return; + sasl_->Abort(); + authExt.unset(user); + } - User* target = ServerInstance->FindNick((*parameters)[3]); - if (!target) - { - ServerInstance->Logs->Log("m_sasl", DEBUG,"User not found in sasl ENCAP event: %s", (*parameters)[3].c_str()); - return; - } + return MOD_RES_PASSTHRU; + } - SaslAuthenticator *sasl_; - if (!target->GetExt("sasl_authenticator", sasl_)) - return; + void OnDecodeMetaData(Extensible* target, const std::string& extname, const std::string& extdata) CXX11_OVERRIDE + { + if ((target == NULL) && (extname == "saslmechlist")) + cap.SetMechlist(extdata); + } - SaslState state = sasl_->ProcessInboundMessage(*parameters); - if (state == SASL_DONE) - { - delete sasl_; - target->Shrink("sasl"); - } - } + Version GetVersion() CXX11_OVERRIDE + { + return Version("Provides support for IRC Authentication Layer (aka: SASL) via AUTHENTICATE.", VF_VENDOR); } };