X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_sasl.cpp;h=c96b8703400c75ebd3d4bc66ddf3fbff0730692f;hb=ece5c62d5733fd2355657962859cded0758a2dac;hp=48da83aaded67039cacf290c1706768b8ca33581;hpb=8793de777349918629d954b2f6bf6419d158dcc2;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_sasl.cpp b/src/modules/m_sasl.cpp index 48da83aad..c96b87034 100644 --- a/src/modules/m_sasl.cpp +++ b/src/modules/m_sasl.cpp @@ -1,121 +1,291 @@ -/* +------------------------------------+ - * | Inspire Internet Relay Chat Daemon | - * +------------------------------------+ +/* + * InspIRCd -- Internet Relay Chat Daemon * - * InspIRCd: (C) 2002-2008 InspIRCd Development Team - * See: http://www.inspircd.org/wiki/index.php/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" -/* $ModDesc: Provides support for atheme SASL via AUTHENTICATE. */ +enum SaslState { SASL_INIT, SASL_COMM, SASL_DONE }; +enum SaslResult { SASL_OK, SASL_FAIL, SASL_ABORT }; -class CommandAuthenticate : public Command +static std::string sasl_target = "*"; +static Events::ModuleEventProvider* saslevprov; + +static void SendSASL(const parameterlist& params) { - Module* Creator; - public: - CommandAuthenticate (InspIRCd* Instance, Module* creator) : Command(Instance,"AUTHENTICATE", 0, 1, true), Creator(creator) + if (!ServerInstance->PI->SendEncapsulatedData(sasl_target, "SASL", params)) { - this->source = "m_sasl.so"; + FOREACH_MOD_CUSTOM(*saslevprov, SASLEventListener, OnSASLAuth, (params)); } +} + +/** + * Tracks SASL authentication state like charybdis does. --nenolod + */ +class SaslAuthenticator +{ + private: + std::string agent; + User *user; + SaslState state; + SaslResult result; + bool state_announced; - CmdResult Handle (const char* const* parameters, int pcnt, User *user) + public: + SaslAuthenticator(User* user_, const std::string& method) + : user(user_), state(SASL_INIT), state_announced(false) { - if (user->registered != REG_ALL) - { - /* Only act if theyve enabled CAP REQ sasl */ - if (user->GetExt("sasl")) - { - /* Only allow AUTHENTICATE on unregistered clients */ - std::deque params; - params.push_back("*"); - params.push_back("AUTHENTICATE"); - params.push_back(user->uuid); + parameterlist params; + params.push_back(user->uuid); + params.push_back("*"); + params.push_back("S"); + params.push_back(method); - for (int i = 0; i < pcnt; ++i) - params.push_back(parameters[i]); + LocalUser* localuser = IS_LOCAL(user); + if (method == "EXTERNAL" && localuser) + { + std::string fp = SSLClientCert::GetFingerprint(&localuser->eh); - Event e((char*)¶ms, Creator, "send_encap"); - e.Send(ServerInstance); - } + if (fp.size()) + params.push_back(fp); } - return CMD_FAILURE; - } -}; + SendSASL(params); + } -class ModuleSASL : public Module -{ - CommandAuthenticate* sasl; - public: - - ModuleSASL(InspIRCd* Me) - : Module(Me) + SaslResult GetSaslResult(const std::string &result_) { - Implementation eventlist[] = { I_OnEvent, I_OnUserRegister }; - ServerInstance->Modules->Attach(eventlist, this, 2); + if (result_ == "F") + return SASL_FAIL; - sasl = new CommandAuthenticate(ServerInstance, this); - ServerInstance->AddCommand(sasl); + if (result_ == "A") + return SASL_ABORT; - 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!"); + return SASL_OK; } - virtual int OnUserRegister(User *user) + /* checks for and deals with a state change. */ + SaslState ProcessInboundMessage(const std::vector &msg) { - if (user->GetExt("sasl")) + switch (this->state) { - user->WriteServ("906 %s :SASL authentication aborted", user->nick); - user->Shrink("sasl"); + case SASL_INIT: + this->agent = msg[0]; + this->state = SASL_COMM; + /* fall through */ + case SASL_COMM: + if (msg[0] != this->agent) + 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[3]); + } + else if (msg[2] == "M") + this->user->WriteNumeric(908, "%s %s :are available SASL mechanisms", this->user->nick.c_str(), msg[3].c_str()); + 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(MODNAME, LOG_DEFAULT, "WTF: SaslState is not a known state (%d)", this->state); + break; } + + return this->state; } - virtual ~ModuleSASL() + void Abort(void) { + this->state = SASL_DONE; + this->result = SASL_ABORT; } - virtual Version GetVersion() + bool SendClientMessage(const std::vector& parameters) { - return Version(1,2,0,1,VF_VENDOR,API_VERSION); + if (this->state != SASL_COMM) + return true; + + 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()); + + SendSASL(params); + + if (parameters[0][0] == '*') + { + this->Abort(); + return false; + } + + return true; } - virtual void OnEvent(Event *ev) + void AnnounceState(void) { - GenericCapHandler(ev, "sasl", "sasl"); + if (this->state_announced) + return; - if (ev->GetEventID() == "encap_received") + switch (this->result) { - /* Received encap reply, look for AUTHENTICATE */ - std::deque* parameters = (std::deque*)ev->GetData(); + case SASL_OK: + this->user->WriteNumeric(903, ":SASL authentication successful"); + break; + case SASL_ABORT: + this->user->WriteNumeric(906, ":SASL authentication aborted"); + break; + case SASL_FAIL: + this->user->WriteNumeric(904, ":SASL authentication failed"); + break; + default: + break; + } - User* target = ServerInstance->FindNick((*parameters)[0]); + this->state_announced = true; + } +}; - if (target) +class CommandAuthenticate : public Command +{ + public: + SimpleExtItem& authExt; + GenericCap& cap; + CommandAuthenticate(Module* Creator, SimpleExtItem& ext, GenericCap& Cap) + : Command(Creator, "AUTHENTICATE", 1), authExt(ext), cap(Cap) + { + works_before_reg = true; + } + + CmdResult Handle (const std::vector& parameters, User *user) + { + /* Only allow AUTHENTICATE on unregistered clients */ + if (user->registered != REG_ALL) + { + if (!cap.ext.get(user)) + return CMD_FAILURE; + + 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 { - /* Found a user */ - parameters->pop_front(); - std::string line = irc::stringjoiner(" ", *parameters, 0, parameters->size() - 1).GetJoined(); - target->WriteServ("AUTHENTICATE %s", line.c_str()); + sasl->AnnounceState(); + authExt.unset(user); } } - else if (ev->GetEventID() == "account_login") + return CMD_FAILURE; + } +}; + +class CommandSASL : public Command +{ + public: + SimpleExtItem& authExt; + CommandSASL(Module* Creator, SimpleExtItem& ext) : Command(Creator, "SASL", 2), authExt(ext) + { + this->flags_needed = FLAG_SERVERONLY; // should not be called by users + } + + CmdResult Handle(const std::vector& parameters, User *user) + { + User* target = ServerInstance->FindNick(parameters[1]); + if ((!target) || (IS_SERVER(target))) + { + ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "User not found in sasl ENCAP event: %s", parameters[1].c_str()); + return CMD_FAILURE; + } + + SaslAuthenticator *sasl = authExt.get(target); + if (!sasl) + return CMD_FAILURE; + + SaslState state = sasl->ProcessInboundMessage(parameters); + if (state == SASL_DONE) { - AccountData* ac = (AccountData*)ev->GetData(); + sasl->AnnounceState(); + authExt.unset(target); + } + return CMD_SUCCESS; + } - if (ac->user->GetExt("sasl")) - { - ac->user->WriteServ("903 %s :SASL authentication successful", ac->user->nick); - ac->user->Shrink("sasl"); - } + RouteDescriptor GetRouting(User* user, const std::vector& parameters) + { + return ROUTE_BROADCAST; + } +}; + +class ModuleSASL : public Module +{ + SimpleExtItem authExt; + GenericCap cap; + CommandAuthenticate auth; + CommandSASL sasl; + Events::ModuleEventProvider sasleventprov; + + public: + ModuleSASL() + : authExt("sasl_auth", ExtensionItem::EXT_USER, this) + , cap(this, "sasl") + , auth(this, authExt, cap) + , sasl(this, authExt) + , sasleventprov(this, "event/sasl") + { + saslevprov = &sasleventprov; + } + + 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!"); + } + + void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE + { + sasl_target = ServerInstance->Config->ConfValue("sasl")->getString("target", "*"); + } + + ModResult OnUserRegister(LocalUser *user) CXX11_OVERRIDE + { + SaslAuthenticator *sasl_ = authExt.get(user); + if (sasl_) + { + sasl_->Abort(); + authExt.unset(user); } + + return MOD_RES_PASSTHRU; + } + + Version GetVersion() CXX11_OVERRIDE + { + return Version("Provides support for IRC Authentication Layer (aka: atheme SASL) via AUTHENTICATE.",VF_VENDOR); } };