X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_sasl.cpp;h=e202bae45181f8538153c6bc2417d59823548240;hb=e2b0f3dc9ef4d56c71d7abda13e6139ca092e387;hp=0ef93ec5ae66476923dfe7eaded192dba54711df;hpb=0337b92c158fa662f04056343affd59315da78db;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_sasl.cpp b/src/modules/m_sasl.cpp index 0ef93ec5a..e202bae45 100644 --- a/src/modules/m_sasl.cpp +++ b/src/modules/m_sasl.cpp @@ -1,8 +1,15 @@ /* * InspIRCd -- Internet Relay Chat Daemon * + * Copyright (C) 2016 Adam + * Copyright (C) 2014 Mantas Mikulėnas + * Copyright (C) 2013-2016, 2018 Attila Molnar + * Copyright (C) 2013, 2017-2020 Sadie Powell + * Copyright (C) 2013 Daniel Vassdal + * Copyright (C) 2012, 2019 Robby * Copyright (C) 2009-2010 Daniel De Graaf - * Copyright (C) 2008 Craig Edwards + * Copyright (C) 2008, 2010 Craig Edwards + * Copyright (C) 2008 Thomas Stagner * * 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 @@ -19,26 +26,159 @@ #include "inspircd.h" -#include "m_cap.h" -#include "account.h" -#include "sasl.h" -#include "ssl.h" +#include "modules/cap.h" +#include "modules/account.h" +#include "modules/sasl.h" +#include "modules/ssl.h" +#include "modules/server.h" -/* $ModDesc: Provides support for IRC Authentication Layer (aka: atheme SASL) via AUTHENTICATE. */ +enum +{ + // From IRCv3 sasl-3.1 + RPL_SASLSUCCESS = 903, + ERR_SASLFAIL = 904, + ERR_SASLTOOLONG = 905, + ERR_SASLABORTED = 906, + RPL_SASLMECHS = 908 +}; + +static std::string sasl_target; + +class ServerTracker + : public ServerProtocol::LinkEventListener +{ + // Stop GCC warnings about the deprecated OnServerSplit event. + using ServerProtocol::LinkEventListener::OnServerSplit; + + 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); + } + + void OnServerSplit(const Server* server, bool error) CXX11_OVERRIDE + { + Update(server, false); + } + + public: + ServerTracker(Module* mod) + : ServerProtocol::LinkEventListener(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 +{ + private: + std::string mechlist; + const ServerTracker& servertracker; + UserCertificateAPI sslapi; + + bool OnRequest(LocalUser* user, bool adding) CXX11_OVERRIDE + { + if (requiressl && sslapi && !sslapi->GetCertificate(user)) + return false; + + // Servers MUST NAK any sasl capability request if the authentication layer + // is unavailable. + return servertracker.IsOnline(); + } + + bool OnList(LocalUser* user) CXX11_OVERRIDE + { + if (requiressl && sslapi && !sslapi->GetCertificate(user)) + return false; + + // Servers MUST NOT advertise the sasl capability if the authentication layer + // is unavailable. + return servertracker.IsOnline(); + } + + const std::string* GetValue(LocalUser* user) const CXX11_OVERRIDE + { + return &mechlist; + } + + public: + bool requiressl; + SASLCap(Module* mod, const ServerTracker& tracker) + : Cap::Capability(mod, "sasl") + , servertracker(tracker) + , sslapi(mod) + { + } + + 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 std::string sasl_target = "*"; +static Events::ModuleEventProvider* saslevprov; -static void SendSASL(const parameterlist& params) +static void SendSASL(LocalUser* user, const std::string& agent, char mode, const std::vector& parameters) { - if (!ServerInstance->PI->SendEncapsulatedData(params)) + CommandBase::Params params; + params.push_back(user->uuid); + params.push_back(agent); + params.push_back(ConvToStr(mode)); + params.insert(params.end(), parameters.begin(), parameters.end()); + + if (!ServerInstance->PI->SendEncapsulatedData(sasl_target, "SASL", params)) { - SASLFallback(NULL, params); + FOREACH_MOD_CUSTOM(*saslevprov, SASLEventListener, OnSASLAuth, (params)); } } +static ClientProtocol::EventProvider* g_protoev; + /** * Tracks SASL authentication state like charybdis does. --nenolod */ @@ -46,95 +186,37 @@ class SaslAuthenticator { private: std::string agent; - User *user; + LocalUser* user; SaslState state; SaslResult result; bool state_announced; - /* taken from m_services_account */ - static bool ReadCGIIRCExt(const char* extname, User* user, std::string& out) - { - ExtensionItem* wiext = ServerInstance->Extensions.GetItem(extname); - if (!wiext) - return false; - - if (wiext->creator->ModuleSourceFile != "m_cgiirc.so") - return false; - - StringExtItem* stringext = static_cast(wiext); - std::string* addr = stringext->get(user); - if (!addr) - return false; - - out = *addr; - return true; - } - - - void SendHostIP() + void SendHostIP(UserCertificateAPI& sslapi) { - std::string host, ip; - - if (!ReadCGIIRCExt("cgiirc_webirc_hostname", user, host)) - { - host = user->host; - } - if (!ReadCGIIRCExt("cgiirc_webirc_ip", user, ip)) - { - ip = user->GetIPString(); - } - else - { - /* IP addresses starting with a : on irc are a Bad Thing (tm) */ - if (ip.c_str()[0] == ':') - ip.insert(ip.begin(),1,'0'); - } - - parameterlist params; - params.push_back(sasl_target); - params.push_back("SASL"); - params.push_back(user->uuid); - params.push_back("*"); - params.push_back("H"); - params.push_back(host); - params.push_back(ip); - - LocalUser* lu = IS_LOCAL(user); - if (lu) - { - // NOTE: SaslAuthenticator instances are only created for local - // users so this parameter will always be appended. - SocketCertificateRequest req(&lu->eh, ServerInstance->Modules->Find("m_sasl.so")); - params.push_back(req.cert ? "S" : "P"); - } + std::vector params; + params.push_back(user->GetRealHost()); + params.push_back(user->GetIPString()); + params.push_back(sslapi && sslapi->GetCertificate(user) ? "S" : "P"); - SendSASL(params); + SendSASL(user, "*", 'H', params); } public: - SaslAuthenticator(User* user_, const std::string& method) - : user(user_), state(SASL_INIT), state_announced(false) + SaslAuthenticator(LocalUser* user_, const std::string& method, UserCertificateAPI& sslapi) + : user(user_) + , state(SASL_INIT) + , state_announced(false) { - SendHostIP(); - - parameterlist params; - params.push_back(sasl_target); - params.push_back("SASL"); - params.push_back(user->uuid); - params.push_back("*"); - params.push_back("S"); - params.push_back(method); + SendHostIP(sslapi); - if (method == "EXTERNAL" && IS_LOCAL(user_)) - { - SocketCertificateRequest req(&((LocalUser*)user_)->eh, ServerInstance->Modules->Find("m_sasl.so")); - std::string fp = req.GetFingerprint(); + std::vector params; + params.push_back(method); - if (fp.size()) - params.push_back(fp); - } + const std::string fp = sslapi ? sslapi->GetFingerprint(user) : ""; + if (!fp.empty()) + params.push_back(fp); - SendSASL(params); + SendSASL(user, "*", 'S', params); } SaslResult GetSaslResult(const std::string &result_) @@ -149,7 +231,7 @@ class SaslAuthenticator } /* checks for and deals with a state change. */ - SaslState ProcessInboundMessage(const std::vector &msg) + SaslState ProcessInboundMessage(const CommandBase::Params& msg) { switch (this->state) { @@ -165,53 +247,47 @@ class SaslAuthenticator return this->state; if (msg[2] == "C") - this->user->Write("AUTHENTICATE %s", msg[3].c_str()); + { + ClientProtocol::Message authmsg("AUTHENTICATE"); + authmsg.PushParamRef(msg[3]); + + ClientProtocol::Event authevent(*g_protoev, authmsg); + LocalUser* const localuser = IS_LOCAL(user); + if (localuser) + localuser->Send(authevent); + } 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()); + this->user->WriteNumeric(RPL_SASLMECHS, msg[3], "are available SASL mechanisms"); else - ServerInstance->Logs->Log("m_sasl", DEFAULT, "Services sent an unknown SASL message \"%s\" \"%s\"", msg[2].c_str(), msg[3].c_str()); + 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; } return this->state; } - void Abort(void) - { - this->state = SASL_DONE; - this->result = SASL_ABORT; - } - bool SendClientMessage(const std::vector& parameters) { if (this->state != SASL_COMM) return true; - parameterlist params; - params.push_back(sasl_target); - params.push_back("SASL"); - 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); + SendSASL(this->user, this->agent, 'C', parameters); if (parameters[0].c_str()[0] == '*') { - this->Abort(); + this->state = SASL_DONE; + this->result = SASL_ABORT; return false; } @@ -226,13 +302,13 @@ class SaslAuthenticator switch (this->result) { case SASL_OK: - this->user->WriteNumeric(903, "%s :SASL authentication successful", this->user->nick.c_str()); + this->user->WriteNumeric(RPL_SASLSUCCESS, "SASL authentication successful"); break; - case SASL_ABORT: - this->user->WriteNumeric(906, "%s :SASL authentication aborted", this->user->nick.c_str()); + case SASL_ABORT: + this->user->WriteNumeric(ERR_SASLABORTED, "SASL authentication aborted"); break; case SASL_FAIL: - this->user->WriteNumeric(904, "%s :SASL authentication failed", this->user->nick.c_str()); + this->user->WriteNumeric(ERR_SASLFAIL, "SASL authentication failed"); break; default: break; @@ -242,32 +318,45 @@ class SaslAuthenticator } }; -class CommandAuthenticate : public Command +class CommandAuthenticate : public SplitCommand { + private: + // The maximum length of an AUTHENTICATE request. + static const size_t MAX_AUTHENTICATE_SIZE = 400; + public: SimpleExtItem& authExt; - GenericCap& cap; - CommandAuthenticate(Module* Creator, SimpleExtItem& ext, GenericCap& Cap) - : Command(Creator, "AUTHENTICATE", 1), authExt(ext), cap(Cap) + Cap::Capability& cap; + UserCertificateAPI sslapi; + + CommandAuthenticate(Module* Creator, SimpleExtItem& ext, Cap::Capability& Cap) + : SplitCommand(Creator, "AUTHENTICATE", 1) + , authExt(ext) + , cap(Cap) + , sslapi(Creator) { works_before_reg = true; allow_empty_last_param = false; } - CmdResult Handle (const std::vector& parameters, User *user) + CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE { - /* Only allow AUTHENTICATE on unregistered clients */ - if (user->registered != REG_ALL) { - if (!cap.ext.get(user)) + if (!cap.get(user)) return CMD_FAILURE; if (parameters[0].find(' ') != std::string::npos || parameters[0][0] == ':') return CMD_FAILURE; + if (parameters[0].length() > MAX_AUTHENTICATE_SIZE) + { + user->WriteNumeric(ERR_SASLTOOLONG, "SASL message too long"); + return CMD_FAILURE; + } + SaslAuthenticator *sasl = authExt.get(user); if (!sasl) - authExt.set(user, new SaslAuthenticator(user, parameters[0])); + authExt.set(user, new SaslAuthenticator(user, parameters[0], sslapi)); else if (sasl->SendClientMessage(parameters) == false) // IAL abort extension --nenolod { sasl->AnnounceState(); @@ -287,12 +376,12 @@ class CommandSASL : public Command this->flags_needed = FLAG_SERVERONLY; // should not be called by users } - CmdResult Handle(const std::vector& parameters, User *user) + CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE { - User* target = ServerInstance->FindNick(parameters[1]); - if ((!target) || (IS_SERVER(target))) + User* target = ServerInstance->FindUUID(parameters[1]); + if (!target) { - ServerInstance->Logs->Log("m_sasl", DEBUG,"User not found in sasl ENCAP event: %s", parameters[1].c_str()); + ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "User not found in sasl ENCAP event: %s", parameters[1].c_str()); return CMD_FAILURE; } @@ -309,7 +398,7 @@ class CommandSASL : public Command return CMD_SUCCESS; } - RouteDescriptor GetRouting(User* user, const std::vector& parameters) + RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE { return ROUTE_BROADCAST; } @@ -318,51 +407,55 @@ class CommandSASL : public Command class ModuleSASL : public Module { SimpleExtItem authExt; - GenericCap cap; + ServerTracker servertracker; + SASLCap cap; CommandAuthenticate auth; CommandSASL sasl; + Events::ModuleEventProvider sasleventprov; + ClientProtocol::EventProvider protoev; + public: ModuleSASL() - : authExt("sasl_auth", this), cap(this, "sasl"), auth(this, authExt, cap), sasl(this, authExt) + : authExt("sasl_auth", ExtensionItem::EXT_USER, this) + , servertracker(this) + , cap(this, servertracker) + , auth(this, authExt, cap) + , sasl(this, authExt) + , sasleventprov(this, "event/sasl") + , protoev(this, auth.name) { + saslevprov = &sasleventprov; + g_protoev = &protoev; } - void init() + void init() CXX11_OVERRIDE { - OnRehash(NULL); - Implementation eventlist[] = { I_OnEvent, I_OnUserConnect, I_OnRehash }; - ServerInstance->Modules->Attach(eventlist, this, sizeof(eventlist)/sizeof(Implementation)); - - ServiceProvider* providelist[] = { &auth, &sasl, &authExt }; - ServerInstance->Modules->AddServices(providelist, 3); - 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!"); + ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "WARNING: m_services_account and m_cap are not loaded! m_sasl will NOT function correctly until these two modules are loaded!"); } - void OnRehash(User*) + void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE { - sasl_target = ServerInstance->Config->ConfValue("sasl")->getString("target", "*"); - } + ConfigTag* tag = ServerInstance->Config->ConfValue("sasl"); - void OnUserConnect(LocalUser *user) - { - SaslAuthenticator *sasl_ = authExt.get(user); - if (sasl_) - { - sasl_->Abort(); - authExt.unset(user); - } + const std::string target = tag->getString("target"); + if (target.empty()) + throw ModuleException(" must be set to the name of your services server!"); + + cap.requiressl = tag->getBool("requiressl"); + sasl_target = target; + servertracker.Reset(); } - Version GetVersion() + void OnDecodeMetaData(Extensible* target, const std::string& extname, const std::string& extdata) CXX11_OVERRIDE { - return Version("Provides support for IRC Authentication Layer (aka: SASL) via AUTHENTICATE.", VF_VENDOR); + if ((target == NULL) && (extname == "saslmechlist")) + cap.SetMechlist(extdata); } - void OnEvent(Event &ev) + Version GetVersion() CXX11_OVERRIDE { - cap.HandleEvent(ev); + return Version("Provides the IRCv3 sasl client capability.", VF_VENDOR); } };