/* +------------------------------------+
* | Inspire Internet Relay Chat Daemon |
* +------------------------------------+
*
* InspIRCd: (C) 2002-2011 InspIRCd Development Team
* See: http://wiki.inspircd.org/Credits
*
* This program is free but copyrighted software; see
* the file COPYING for details.
*
* ---------------------------------------------------
*/
#include "inspircd.h"
#include "protocol.h"
#include "account.h"
#include "hash.h"
/* $ModDesc: Allow users to register their own accounts */
static dynamic_reference<AccountProvider> accounts("account");
static dynamic_reference<AccountDBProvider> db("accountdb");
static bool IsValidEmail(const std::string& emailaddr)
{
// We consider an email valid if it contains exactly one @ sign that isn't at the very beginning or end.
// We don't check for a dot because some email addresses don't have one, such as root@localhost
std::string::size_type pos = emailaddr.find_first_of('@');
return pos != std::string::npos && pos != 0 && pos != emailaddr.length() - 1 && pos == emailaddr.find_last_of('@');
}
/** Handle /REGISTER
*/
class CommandRegister : public Command
{
const std::string& hashtype;
const std::set<irc::string>& recentlydropped;
const unsigned int& maxregcount;
TSStringExtItem& email;
public:
LocalIntExt regcount;
CommandRegister(Module* Creator, const std::string& hashtype_ref, const std::set<irc::string>& recentlydropped_ref, TSStringExtItem& email_ref, const unsigned int& maxregcount_ref) :
Command(Creator,"REGISTER", 1, 2), hashtype(hashtype_ref), recentlydropped(recentlydropped_ref), maxregcount(maxregcount_ref), email(email_ref), regcount(EXTENSIBLE_USER, "regcount", Creator)
{
syntax = "<password> [email]";
}
CmdResult Handle (const std::vector<std::string>& parameters, User *user)
{
if (!ServerInstance->IsNick(user->nick.c_str(), ServerInstance->Config->Limits.NickMax))
{
user->WriteServ("NOTICE %s :You may not register your UID", user->nick.c_str());
return CMD_FAILURE;
}
if (accounts && accounts->IsRegistered(user))
{
user->WriteServ("NOTICE %s :You are already logged in to an account", user->nick.c_str());
return CMD_FAILURE;
}
if(recentlydropped.find(user->nick) != recentlydropped.end())
{
user->WriteServ("NOTICE %s :Account %s was dropped less than an hour ago and may not yet be re-registered", user->nick.c_str(), user->nick.c_str());
return CMD_FAILURE;
}
unsigned int user_regcount = regcount.get(user);
if(maxregcount && user_regcount >= maxregcount && !user->HasPrivPermission("accounts/no-registration-limit"))
{
user->WriteServ("NOTICE %s :You have already registered the maximum number of accounts for this session", user->nick.c_str());
return CMD_FAILURE;
}
if(parameters.size() == 2 && !IsValidEmail(parameters[1]))
{
user->WriteServ("NOTICE %s :The email address provided is invalid", user->nick.c_str());
return CMD_FAILURE;
}
// Don't send this now. Wait until we have the password set.
AccountDBEntry* entry = db->AddAccount(false, user->nick, ServerInstance->Time(), hashtype);
if(!entry)
{
user->WriteServ("NOTICE %s :Account %s already exists", user->nick.c_str(), user->nick.c_str());
return CMD_FAILURE;
}
entry->hash_password_ts = entry->ts;
// XXX: The code to generate a hash was copied from m_password_hash. We may want a better way to do this.
if (hashtype == "plaintext" || hashtype.empty())
entry->password = parameters[0];
else if (hashtype.substr(0,5) == "hmac-")
{
std::string type = hashtype.substr(5);
HashProvider* hp = ServerInstance->Modules->FindDataService<HashProvider>("hash/" + type);
if (!hp)
{
entry->hash = "plaintext";
entry->password = parameters[0];
ServerInstance->Logs->Log ("MODULE", DEFAULT, "unknown hash type in m_account_register, not using a hash");
}
else
{
std::string salt = ServerInstance->GenRandomStr(6, false);
entry->password = BinToBase64(salt) + "$" + BinToBase64(hp->hmac(salt, parameters[0]), NULL, 0);
}
}
else
{
HashProvider* hp = ServerInstance->Modules->FindDataService<HashProvider>("hash/" + hashtype);
if (hp)
{
entry->password = hp->hexsum(parameters[0]);
}
else
{
entry->hash = "plaintext";
entry->password = parameters[0];
ServerInstance->Logs->Log ("MODULE", DEFAULT, "unknown hash type in m_account_register, not using a hash");
}
}
if(parameters.size() == 2)
email.set(entry, parameters[1]);
db->SendAccount(entry);
regcount.set(user, user_regcount + 1);
if(parameters.size() == 2)
ServerInstance->SNO->WriteGlobalSno('u', "%s used REGISTER to register a new account with email %s", user->nick.c_str(), parameters[1].c_str());
else
ServerInstance->SNO->WriteGlobalSno('u', "%s used REGISTER to register a new account", user->nick.c_str());
if(accounts) accounts->DoLogin(user, entry->name, "");
return CMD_SUCCESS;
}
};
/** Handle /SETEMAIL
*/
class CommandSetemail : public Command
{
TSStringExtItem& email;
public:
CommandSetemail(Module* Creator, TSStringExtItem& email_ref) : Command(Creator,"SETEMAIL", 0, 1), email(email_ref)
{
syntax = "[new email]";
}
CmdResult Handle (const std::vector<std::string>& parameters, User *user)
{
AccountDBEntry* entry;
if(!accounts || !accounts->IsRegistered(user) || !(entry = db->GetAccount(accounts->GetAccountName(user), false)))
{
user->WriteServ("NOTICE %s :You are not logged in", user->nick.c_str());
return CMD_FAILURE;
}
if(parameters.empty() || parameters[0].empty())
{
if(min_params)
{
// We could get here if we got "SETEMAIL :"
user->WriteServ("NOTICE %s :An email address is required", user->nick.c_str());
return CMD_FAILURE;
}
email.set(entry, "");
db->SendUpdate(entry, "Email_address");
ServerInstance->SNO->WriteGlobalSno('u', "%s cleared the email address of account %s", user->nick.c_str(), entry->name.c_str());
user->WriteServ("NOTICE %s :Account %s email removed", user->nick.c_str(), entry->name.c_str());
return CMD_SUCCESS;
}
else if(!IsValidEmail(parameters[0]))
{
user->WriteServ("NOTICE %s :The email address provided is invalid", user->nick.c_str());
return CMD_FAILURE;
}
else
{
email.set(entry, parameters[0]);
db->SendUpdate(entry, "Email_address");
ServerInstance->SNO->WriteGlobalSno('u', "%s set the email address of account %s to %s", user->nick.c_str(), entry->name.c_str(), parameters[0].c_str());
user->WriteServ("NOTICE %s :Account %s email set to %s", user->nick.c_str(), entry->name.c_str(), parameters[0].c_str());
return CMD_SUCCESS;
}
}
};
/** Handle /SETPASS
*/
class CommandSetpass : public Command
{
const std::string& hashtype;
public:
CommandSetpass(Module* Creator, const std::string& hashtype_ref) : Command(Creator,"SETPASS", 2, 3), hashtype(hashtype_ref)
{
syntax = "[username] <old password> <new password>";
}
CmdResult Handle (const std::vector<std::string>& parameters, User *user)
{
irc::string username;
std::string oldpass, newpass;
if(parameters.size() == 2)
{
if(accounts && accounts->IsRegistered(user))
username = accounts->GetAccountName(user);
else
username = user->nick;
oldpass = parameters[0];
newpass = parameters[1];
}
else
{
username = parameters[0];
oldpass = parameters[1];
newpass = parameters[2];
}
if(newpass.empty())
{
user->WriteServ("NOTICE %s :You must specify a new password", user->nick.c_str());
return CMD_FAILURE;
}
AccountDBEntry* entry = db->GetAccount(username, false);
if(!entry || entry->password.empty() || ServerInstance->PassCompare(user, entry->password, oldpass, entry->hash))
{
user->WriteServ("NOTICE %s :Invalid username or password", user->nick.c_str());
return CMD_FAILURE;
}
entry->hash = hashtype;
// XXX: The code to generate a hash was copied from m_password_hash. We may want a better way to do this.
if (hashtype == "plaintext" || hashtype.empty())
entry->password = newpass;
else if (hashtype.substr(0,5) == "hmac-")
{
std::string type = hashtype.substr(5);
HashProvider* hp = ServerInstance->Modules->FindDataService<HashProvider>("hash/" + type);
if (!hp)
{
entry->hash = "plaintext";
entry->password = newpass;
ServerInstance->Logs->Log ("MODULE", DEFAULT, "unknown hash type in m_account_register, not using a hash");
}
else
{
std::string salt = ServerInstance->GenRandomStr(6, false);
entry->password = BinToBase64(salt) + "$" + BinToBase64(hp->hmac(salt, newpass), NULL, 0);
}
}
else
{
HashProvider* hp = ServerInstance->Modules->FindDataService<HashProvider>("hash/" + hashtype);
if (hp)
{
entry->password = hp->hexsum(newpass);
}
else
{
entry->hash = "plaintext";
entry->password = newpass;
ServerInstance->Logs->Log ("MODULE", DEFAULT, "unknown hash type in m_account_register, not using a hash");
}
}
entry->hash_password_ts = ServerInstance->Time();
db->SendUpdate(entry, "hash_password");
user->WriteServ("NOTICE %s :Account %s password changed successfully", user->nick.c_str(), entry->name.c_str());
return CMD_SUCCESS;
}
};
/** Handle /FSETPASS
*/
class CommandFsetpass : public Command
{
const std::string& hashtype;
public:
CommandFsetpass(Module* Creator, const std::string& hashtype_ref) : Command(Creator,"FSETPASS", 2, 2), hashtype(hashtype_ref)
{
flags_needed = 'o'; syntax = "<username> <new password>";
}
CmdResult Handle (const std::vector<std::string>& parameters, User *user)
{
AccountDBEntry* entry = db->GetAccount(parameters[0], false);
if(!entry)
{
user->WriteServ("NOTICE %s :No such account", user->nick.c_str());
return CMD_FAILURE;
}
if(parameters[1].empty())
{
user->WriteServ("NOTICE %s :You must specify a new password", user->nick.c_str());
return CMD_FAILURE;
}
entry->hash = hashtype;
// XXX: The code to generate a hash was copied from m_password_hash. We may want a better way to do this.
if (hashtype == "plaintext" || hashtype.empty())
entry->password = parameters[1];
else if (hashtype.substr(0,5) == "hmac-")
{
std::string type = hashtype.substr(5);
HashProvider* hp = ServerInstance->Modules->FindDataService<HashProvider>("hash/" + type);
if (!hp)
{
entry->hash = "plaintext";
entry->password = parameters[1];
ServerInstance->Logs->Log ("MODULE", DEFAULT, "unknown hash type in m_account_register, not using a hash");
}
else
{
std::string salt = ServerInstance->GenRandomStr(6, false);
entry->password = BinToBase64(salt) + "$" + BinToBase64(hp->hmac(salt, parameters[1]), NULL, 0);
}
}
else
{
HashProvider* hp = ServerInstance->Modules->FindDataService<HashProvider>("hash/" + hashtype);
if (hp)
{
entry->password = hp->hexsum(parameters[1]);
}
else
{
entry->hash = "plaintext";
entry->password = parameters[1];
ServerInstance->Logs->Log ("MODULE", DEFAULT, "unknown hash type in m_account_register, not using a hash");
}
}
entry->hash_password_ts = ServerInstance->Time();
db->SendUpdate(entry, "hash_password");
ServerInstance->SNO->WriteGlobalSno('a', "%s used FSETPASS to force password change of account '%s'", user->nick.c_str(), entry->name.c_str());
user->WriteServ("NOTICE %s :Account %s force-password changed successfully", user->nick.c_str(), entry->name.c_str());
return CMD_SUCCESS;
}
};
/** Handle /DROP
*/
class CommandDrop : public Command
{
std::set<irc::string>& recentlydropped;
public:
CommandDrop(Module* Creator, std::set<irc::string>& recentlydropped_ref) : Command(Creator,"DROP", 1, 2), recentlydropped(recentlydropped_ref)
{
syntax = "[account name] <password>";
}
CmdResult Handle (const std::vector<std::string>& parameters, User *user)
{
irc::string username;
std::string password;
if(parameters.size() == 1)
{
if(accounts && accounts->IsRegistered(user))
username = accounts->GetAccountName(user);
else
username = user->nick;
password = parameters[0];
}
else
{
username = parameters[0];
password = parameters[1];
}
AccountDBEntry* entry = db->GetAccount(username, false);
if(!entry || entry->password.empty() || ServerInstance->PassCompare(user, entry->password, password, entry->hash))
{
user->WriteServ("NOTICE %s :Invalid username or password", user->nick.c_str());
return CMD_FAILURE;
}
if(!accounts || username != accounts->GetAccountName(user))
user->WriteServ("NOTICE %s :Account %s has been dropped", user->nick.c_str(), username.c_str());
recentlydropped.insert(entry->name);
std::vector<std::string> params;
params.push_back("*");
params.push_back("RECENTLYDROPPED");
params.push_back(entry->name);
ServerInstance->PI->SendEncapsulatedData(params);
ServerInstance->SNO->WriteGlobalSno('u', "%s used DROP to drop account %s", user->nick.c_str(), entry->name.c_str());
db->RemoveAccount(true, entry);
return CMD_SUCCESS;
}
};
/** Handle /FDROP
*/
class CommandFdrop : public Command
{
std::set<irc::string>& recentlydropped;
public:
CommandFdrop(Module* Creator, std::set<irc::string>& recentlydropped_ref) : Command(Creator,"FDROP", 1, 1), recentlydropped(recentlydropped_ref)
{
flags_needed = 'o'; syntax = "<account name>";
}
CmdResult Handle (const std::vector<std::string>& parameters, User *user)
{
AccountDBEntry* entry = db->GetAccount(parameters[0], false);
if(!entry)
{
user->WriteServ("NOTICE %s :No such account", user->nick.c_str());
return CMD_FAILURE;
}
ServerInstance->SNO->WriteGlobalSno('a', "%s used FDROP to force drop of account '%s'", user->nick.c_str(), entry->name.c_str());
user->WriteServ("NOTICE %s :Account %s force-dropped successfully", user->nick.c_str(), entry->name.c_str());
recentlydropped.insert(entry->name);
std::vector<std::string> params;
params.push_back("*");
params.push_back("RECENTLYDROPPED");
params.push_back(entry->name);
ServerInstance->PI->SendEncapsulatedData(params);
db->RemoveAccount(true, entry);
return CMD_SUCCESS;
}
};
/** Handle /HOLD
*/
class CommandHold : public Command
{
public:
TSBoolExtItem held;
CommandHold(Module* Creator) : Command(Creator,"HOLD", 2, 2), held("Held", false, true, Creator)
{
flags_needed = 'o'; syntax = "<account name> OFF|ON";
}
CmdResult Handle (const std::vector<std::string>& parameters, User *user)
{
bool newsetting;
if(irc::string(parameters[1]) == "ON")
newsetting = true;
else if(irc::string(parameters[1]) == "OFF")
newsetting = false;
else
{
user->WriteServ("NOTICE %s :Unknown setting", user->nick.c_str());
return CMD_FAILURE;
}
AccountDBEntry* entry = db->GetAccount(parameters[0], false);
if(!entry)
{
user->WriteServ("NOTICE %s :No such account", user->nick.c_str());
return CMD_FAILURE;
}
held.set(entry, newsetting);
db->SendUpdate(entry, "Held");
ServerInstance->SNO->WriteGlobalSno('a', "%s used HOLD to %sable hold of account '%s'", user->nick.c_str(), newsetting ? "en" : "dis", entry->name.c_str());
user->WriteServ("NOTICE %s :Account %s %sheld successfully", user->nick.c_str(), entry->name.c_str(), newsetting ? "" : "un");
return CMD_SUCCESS;
}
};
/** Handle /RECENTLYDROPPED
*/
class CommandRecentlydropped : public Command
{
std::set<irc::string>& recentlydropped;
public:
CommandRecentlydropped(Module* Creator, std::set<irc::string>& recentlydropped_ref) : Command(Creator,"RECENTLYDROPPED", 1, 1), recentlydropped(recentlydropped_ref)
{
flags_needed = FLAG_SERVERONLY; syntax = "<account name>";
}
CmdResult Handle (const std::vector<std::string>& parameters, User*)
{
recentlydropped.insert(parameters[0]);
return CMD_SUCCESS;
}
};
class ModuleAccountRegister : public Module
{
time_t expiretime;
std::string hashtype;
std::set<irc::string> recentlydropped;
unsigned int maxregcount;
TSStringExtItem email;
CommandRegister cmd_register;
CommandSetemail cmd_setemail;
CommandSetpass cmd_setpass;
CommandFsetpass cmd_fsetpass;
CommandDrop cmd_drop;
CommandFdrop cmd_fdrop;
CommandHold cmd_hold;
CommandRecentlydropped cmd_recentlydropped;
TSExtItem last_used;
public:
ModuleAccountRegister() : email("Email_address", "", this), cmd_register(this, hashtype, recentlydropped, email, maxregcount),
cmd_setemail(this, email), cmd_setpass(this, hashtype), cmd_fsetpass(this, hashtype),
cmd_drop(this, recentlydropped), cmd_fdrop(this, recentlydropped), cmd_hold(this),
cmd_recentlydropped(this, recentlydropped), last_used("Last_used", this)
{
}
void init()
{
if(!db) throw ModuleException("m_account_register requires that m_account be loaded");
ServerInstance->Modules->AddService(email);
ServerInstance->Modules->AddService(cmd_register);
ServerInstance->Modules->AddService(cmd_register.regcount);
ServerInstance->Modules->AddService(cmd_setemail);
ServerInstance->Modules->AddService(cmd_setpass);
ServerInstance->Modules->AddService(cmd_fsetpass);
ServerInstance->Modules->AddService(cmd_drop);
ServerInstance->Modules->AddService(cmd_fdrop);
ServerInstance->Modules->AddService(cmd_hold);
ServerInstance->Modules->AddService(cmd_hold.held);
ServerInstance->Modules->AddService(cmd_recentlydropped);
ServerInstance->Modules->AddService(last_used);
Implementation eventlist[] = { I_OnEvent, I_OnSyncNetwork, I_OnGarbageCollect };
ServerInstance->Modules->Attach(eventlist, this, sizeof(eventlist)/sizeof(Implementation));
}
void ReadConfig(ConfigReadStatus&)
{
ConfigTag* conf = ServerInstance->Config->GetTag("acctregister");
hashtype = conf->getString("hashtype", "plaintext");
expiretime = ServerInstance->Duration (conf->getString ("expiretime", "21d"));
maxregcount = conf->getInt("maxregcount", 3);
if(expiretime && expiretime < 7200)
{
ServerInstance->Logs->Log ("MODULE", DEFAULT, "account expiration times of under 2 hours are unsafe, setting to 2 hours");
expiretime = 7200;
}
if(conf->getBool("emailrequired"))
{
cmd_register.min_params = 2;
cmd_register.syntax = "<password> <email>";
cmd_setemail.min_params = 1;
cmd_setemail.syntax = "<new email>";
}
else
{
cmd_register.min_params = 1;
cmd_register.syntax = "<password> [email]";
cmd_setemail.min_params = 0;
cmd_setemail.syntax = "[new email]";
}
}
void OnEvent(Event& event)
{
if(event.id == "account_login"){
AccountEvent& acct_event = static_cast<AccountEvent&>(event);
if(!IS_LOCAL(acct_event.user))
return;
AccountDBEntry* entry = db->GetAccount(acct_event.account, false);
if(!entry)
return;
last_used.set(entry, ServerInstance->Time());
db->SendUpdate(entry, "Last_used");
}
}
virtual void OnSyncNetwork(SyncTarget* target)
{
for (std::set<irc::string>::const_iterator i = recentlydropped.begin(); i != recentlydropped.end(); ++i)
target->SendCommand("ENCAP * RECENTLYDROPPED " + i->value);
}
void OnGarbageCollect()
{
std::string account_name;
AccountDBEntry* entry;
time_t threshold = ServerInstance->Time() - expiretime;
time_t* last_used_time;
bool* held;
recentlydropped.clear();
for (user_hash::const_iterator i = ServerInstance->Users->clientlist->begin(); i != ServerInstance->Users->clientlist->end(); ++i)
{
if(!IS_LOCAL(i->second))
continue;
account_name = accounts->GetAccountName(i->second);
if(account_name.empty())
continue;
entry = db->GetAccount(account_name, false);
if(!entry)
continue;
last_used.set(entry, ServerInstance->Time()); // ServerInstance->Time() is inlined, so we would gain nothing by using a temporary variable
db->SendUpdate(entry, "Last_used");
}
if(!expiretime) return;
for (AccountDB::const_iterator i = db->GetDB().begin(); i != db->GetDB().end();)
{
entry = i++->second;
last_used_time = last_used.get(entry);
held = cmd_hold.held.get_value(entry);
if((!last_used_time || *last_used_time < threshold) && !(held && *held))
{
ServerInstance->SNO->WriteGlobalSno('u', "Account %s has expired", entry->name.c_str());
db->RemoveAccount(true, entry);
}
}
}
void Prioritize()
{
ServerInstance->Modules->SetPriority(this, I_ModuleInit, PRIORITY_AFTER, ServerInstance->Modules->Find("m_account.so"));
}
Version GetVersion()
{
return Version("Allow users to register their own accounts", VF_VENDOR);
}
};
MODULE_INIT(ModuleAccountRegister)
