AccountMgr.cpp

Go to the documentation of this file.

/*
* This file is part of Project SkyFire https://www.projectskyfire.org.
* See LICENSE.md file for Copyright information
*/
 
#include "AccountMgr.h"
#include "CryptoHash.h"
#include "Config.h"
#include "DatabaseEnv.h"
#include "ObjectAccessor.h"
#include "Player.h"
#include "SRP6.h"
#include "Util.h"
#include "WorldSession.h"
 
AccountMgr::AccountMgr() { }
 
AccountMgr::~AccountMgr()
{
    ClearRBAC();
}
 
AccountOpResult AccountMgr::CreateAccount(std::string username, std::string password, std::string email = "")
{
    if (utf8length(username) > MAX_ACCOUNT_STR)
        return AccountOpResult::AOR_NAME_TOO_LONG;                           // username's too long
 
    normalizeString(username);
    normalizeString(password);
    normalizeString(email);
 
    if (GetId(username))
        return AccountOpResult::AOR_NAME_ALREADY_EXIST;                       // username does already exist
 
    PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_ACCOUNT);
 
    stmt->setString(0, username);
    auto [salt, verifier] = SkyFire::Crypto::SRP6::MakeRegistrationData(username, password);
    stmt->setBinary(1, salt);
    stmt->setBinary(2, verifier);
    stmt->setString(3, email);
    stmt->setString(4, email);
 
    LoginDatabase.DirectExecute(stmt); // Enforce saving, otherwise AddGroup can fail
 
    stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_REALM_CHARACTERS_INIT);
    LoginDatabase.Execute(stmt);
 
    if (sWorld->GetBoolConfig(WorldBoolConfigs::CONFIG_BOOST_NEW_ACCOUNT))
    {
        stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_ACCOUNT_BOOST);
        stmt->setBool(0, true);
        stmt->setUInt32(1, GetId(username));
 
        LoginDatabase.Execute(stmt);
    }
 
    return AccountOpResult::AOR_OK;                                          // everything's fine
}
 
AccountOpResult AccountMgr::DeleteAccount(uint32 accountId)
{
    // Check if accounts exists
    PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_BY_ID);
    stmt->setUInt32(0, accountId);
    PreparedQueryResult result = LoginDatabase.Query(stmt);
 
    if (!result)
        return AccountOpResult::AOR_NAME_NOT_EXIST;
 
    // Obtain accounts characters
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARS_BY_ACCOUNT_ID);
 
    stmt->setUInt32(0, accountId);
 
    result = CharacterDatabase.Query(stmt);
 
    if (result)
    {
        do
        {
            uint32 guidLow = (*result)[0].GetUInt32();
            uint64 guid = MAKE_NEW_GUID(guidLow, 0, HIGHGUID_PLAYER);
 
            // Kick if player is online
            if (Player* p = ObjectAccessor::FindPlayer(guid))
            {
                WorldSession* s = p->GetSession();
                s->KickPlayer();                            // mark session to remove at next session list update
                s->LogoutPlayer(false);                     // logout player without waiting next session list update
            }
 
            Player::DeleteFromDB(guid, accountId, false);       // no need to update realm characters
        } while (result->NextRow());
    }
 
    // table realm specific but common for all characters of account for realm
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_TUTORIALS);
    stmt->setUInt32(0, accountId);
    CharacterDatabase.Execute(stmt);
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ACCOUNT_DATA);
    stmt->setUInt32(0, accountId);
    CharacterDatabase.Execute(stmt);
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHARACTER_BAN);
    stmt->setUInt32(0, accountId);
    CharacterDatabase.Execute(stmt);
 
    SQLTransaction trans = LoginDatabase.BeginTransaction();
 
    stmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_ACCOUNT);
    stmt->setUInt32(0, accountId);
    trans->Append(stmt);
 
    stmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_ACCOUNT_ACCESS);
    stmt->setUInt32(0, accountId);
    trans->Append(stmt);
 
    stmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_REALM_CHARACTERS);
    stmt->setUInt32(0, accountId);
    trans->Append(stmt);
 
    stmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_ACCOUNT_BANNED);
    stmt->setUInt32(0, accountId);
    trans->Append(stmt);
 
    LoginDatabase.CommitTransaction(trans);
 
    return AccountOpResult::AOR_OK;
}
 
AccountOpResult AccountMgr::ChangeUsername(uint32 accountId, std::string newUsername, std::string newPassword)
{
    // Check if accounts exists
    PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_BY_ID);
    stmt->setUInt32(0, accountId);
    PreparedQueryResult result = LoginDatabase.Query(stmt);
 
    if (!result)
        return AccountOpResult::AOR_NAME_NOT_EXIST;
 
    if (utf8length(newUsername) > MAX_ACCOUNT_STR)
        return AccountOpResult::AOR_NAME_TOO_LONG;
 
    if (utf8length(newPassword) > MAX_ACCOUNT_STR)
        return AccountOpResult::AOR_PASS_TOO_LONG;
 
    normalizeString(newUsername);
    normalizeString(newPassword);
 
    stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_USERNAME);
 
    stmt->setString(0, newUsername);
    stmt->setUInt32(1, accountId);
    LoginDatabase.Execute(stmt);
 
    auto [salt, verifier] = SkyFire::Crypto::SRP6::MakeRegistrationData(newUsername, newPassword);
    stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_LOGON);
    stmt->setBinary(0, salt);
    stmt->setBinary(1, verifier);
    stmt->setUInt32(2, accountId);
 
    LoginDatabase.Execute(stmt);
 
    return AccountOpResult::AOR_OK;
}
 
AccountOpResult AccountMgr::ChangePassword(uint32 accountId, std::string newPassword)
{
    std::string username;
 
    if (!GetName(accountId, username))
        return AccountOpResult::AOR_NAME_NOT_EXIST;                          // account doesn't exist
 
    if (utf8length(newPassword) > MAX_ACCOUNT_STR)
        return AccountOpResult::AOR_PASS_TOO_LONG;
 
    normalizeString(username);
    normalizeString(newPassword);
 
    auto [salt, verifier] = SkyFire::Crypto::SRP6::MakeRegistrationData(username, newPassword);
 
    PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_LOGON);
    stmt->setBinary(0, salt);
    stmt->setBinary(1, verifier);
    stmt->setUInt32(2, accountId);;
 
    LoginDatabase.Execute(stmt);
 
    return AccountOpResult::AOR_OK;
}
 
AccountOpResult AccountMgr::ChangeEmail(uint32 accountId, std::string newEmail)
{
    std::string username;
 
    if (!GetName(accountId, username))
        return AccountOpResult::AOR_NAME_NOT_EXIST;                          // account doesn't exist
 
    if (utf8length(newEmail) > MAX_EMAIL_STR)
        return AccountOpResult::AOR_EMAIL_TOO_LONG;
 
    normalizeString(username);
    normalizeString(newEmail);
 
    PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_EMAIL);
 
    stmt->setString(0, newEmail);
    stmt->setUInt32(1, accountId);
 
    LoginDatabase.Execute(stmt);
 
    return AccountOpResult::AOR_OK;
}
 
AccountOpResult AccountMgr::ChangeRegEmail(uint32 accountId, std::string newEmail)
{
    std::string username;
 
    if (!GetName(accountId, username))
        return AccountOpResult::AOR_NAME_NOT_EXIST;                          // account doesn't exist
 
    if (utf8length(newEmail) > MAX_EMAIL_STR)
        return AccountOpResult::AOR_EMAIL_TOO_LONG;
 
    normalizeString(username);
    normalizeString(newEmail);
 
    PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_REG_EMAIL);
 
    stmt->setString(0, newEmail);
    stmt->setUInt32(1, accountId);
 
    LoginDatabase.Execute(stmt);
 
    return AccountOpResult::AOR_OK;
}
 
uint32 AccountMgr::GetId(std::string const& username)
{
    PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_GET_ACCOUNT_ID_BY_USERNAME);
    stmt->setString(0, username);
    PreparedQueryResult result = LoginDatabase.Query(stmt);
 
    return (result) ? (*result)[0].GetUInt32() : 0;
}
 
AccountTypes AccountMgr::GetSecurity(uint32 accountId)
{
    PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_GET_ACCOUNT_ACCESS_GMLEVEL);
    stmt->setUInt32(0, accountId);
    PreparedQueryResult result = LoginDatabase.Query(stmt);
 
    return (result) ? AccountTypes((*result)[0].GetUInt8()) : AccountTypes::SEC_PLAYER;
}
 
AccountTypes AccountMgr::GetSecurity(uint32 accountId, int32 realmId)
{
    PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_GET_GMLEVEL_BY_REALMID);
    stmt->setUInt32(0, accountId);
    stmt->setInt32(1, realmId);
    PreparedQueryResult result = LoginDatabase.Query(stmt);
 
    return (result) ? AccountTypes((*result)[0].GetUInt8()) : AccountTypes::SEC_PLAYER;
}
 
bool AccountMgr::GetName(uint32 accountId, std::string& name)
{
    PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_GET_USERNAME_BY_ID);
    stmt->setUInt32(0, accountId);
    PreparedQueryResult result = LoginDatabase.Query(stmt);
 
    if (result)
    {
        name = (*result)[0].GetString();
        return true;
    }
 
    return false;
}
 
bool AccountMgr::GetEmail(uint32 accountId, std::string& email)
{
    PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_GET_EMAIL_BY_ID);
    stmt->setUInt32(0, accountId);
    PreparedQueryResult result = LoginDatabase.Query(stmt);
 
    if (result)
    {
        email = (*result)[0].GetString();
        return true;
    }
 
    return false;
}
 
bool AccountMgr::CheckPassword(uint32 accountId, std::string password)
{
    std::string username;
 
    if (!GetName(accountId, username))
        return false;
 
    normalizeString(username);
    normalizeString(password);
 
    PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_CHECK_PASSWORD);
    stmt->setUInt32(0, accountId);
    if (PreparedQueryResult result = LoginDatabase.Query(stmt))
    {
        SkyFire::Crypto::SRP6::Salt salt = (*result)[0].GetBinary<SkyFire::Crypto::SRP6::SALT_LENGTH>();
        SkyFire::Crypto::SRP6::Verifier verifier = (*result)[1].GetBinary<SkyFire::Crypto::SRP6::VERIFIER_LENGTH>();
        if (SkyFire::Crypto::SRP6::CheckLogin(username, password, salt, verifier))
            return true;
    }
 
    return false;
}
 
bool AccountMgr::CheckEmail(uint32 accountId, std::string newEmail)
{
    std::string oldEmail;
 
    // We simply return false for a non-existing email
    if (!GetEmail(accountId, oldEmail))
        return false;
 
    normalizeString(oldEmail);
    normalizeString(newEmail);
 
    if (strcmp(oldEmail.c_str(), newEmail.c_str()) == 0)
        return true;
 
    return false;
}
 
uint32 AccountMgr::GetCharactersCount(uint32 accountId)
{
    // check character count
    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_SUM_CHARS);
    stmt->setUInt32(0, accountId);
    PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
    return (result) ? (*result)[0].GetUInt64() : 0;
}
 
bool AccountMgr::normalizeString(std::string& utf8String)
{
    wchar_t buffer[MAX_ACCOUNT_STR + 1];
 
    size_t maxLength = MAX_ACCOUNT_STR;
    if (!Utf8toWStr(utf8String, buffer, maxLength))
        return false;
#ifdef _MSC_VER
#pragma warning(disable: 4996)
#endif
    std::transform(&buffer[0], buffer + maxLength, &buffer[0], wcharToUpperOnlyLatin);
#ifdef _MSC_VER
#pragma warning(default: 4996)
#endif
 
    return WStrToUtf8(buffer, maxLength, utf8String);
}
 
bool AccountMgr::IsPlayerAccount(AccountTypes gmlevel)
{
    return gmlevel == AccountTypes::SEC_PLAYER;
}
 
bool AccountMgr::IsAdminAccount(AccountTypes gmlevel)
{
    return gmlevel >= AccountTypes::SEC_ADMINISTRATOR && gmlevel <= AccountTypes::SEC_CONSOLE;
}
 
bool AccountMgr::IsConsoleAccount(AccountTypes gmlevel)
{
    return gmlevel == AccountTypes::SEC_CONSOLE;
}
 
void AccountMgr::LoadRBAC()
{
    ClearRBAC();
 
    SF_LOG_DEBUG("rbac", "AccountMgr::LoadRBAC");
    uint32 oldMSTime = getMSTime();
    uint32 count1 = 0;
    uint32 count2 = 0;
    uint32 count3 = 0;
 
    SF_LOG_DEBUG("rbac", "AccountMgr::LoadRBAC: Loading permissions");
    QueryResult result = LoginDatabase.Query("SELECT id, name FROM rbac_permissions");
    if (!result)
    {
        SF_LOG_INFO("server.loading", ">> Loaded 0 account permission definitions. DB table `rbac_permissions` is empty.");
        return;
    }
 
    do
    {
        Field* field = result->Fetch();
        uint32 id = field[0].GetUInt32();
        _permissions[id] = new rbac::RBACPermission(id, field[1].GetString());
        ++count1;
    } while (result->NextRow());
 
    SF_LOG_DEBUG("rbac", "AccountMgr::LoadRBAC: Loading linked permissions");
    result = LoginDatabase.Query("SELECT id, linkedId FROM rbac_linked_permissions ORDER BY id ASC");
    if (!result)
    {
        SF_LOG_INFO("server.loading", ">> Loaded 0 linked permissions. DB table `rbac_linked_permissions` is empty.");
        return;
    }
 
    uint32 permissionId = 0;
    rbac::RBACPermission* permission = NULL;
 
    do
    {
        Field* field = result->Fetch();
        uint32 newId = field[0].GetUInt32();
        if (permissionId != newId)
        {
            permissionId = newId;
            permission = _permissions[newId];
        }
 
        uint32 linkedPermissionId = field[1].GetUInt32();
        if (linkedPermissionId == permissionId)
        {
            SF_LOG_ERROR("sql.sql", "RBAC Permission %u has itself as linked permission. Ignored", permissionId);
            continue;
        }
        permission->AddLinkedPermission(linkedPermissionId);
        ++count2;
    } while (result->NextRow());
 
    SF_LOG_DEBUG("rbac", "AccountMgr::LoadRBAC: Loading default permissions");
    result = LoginDatabase.Query("SELECT secId, permissionId FROM rbac_default_permissions ORDER BY secId ASC");
    if (!result)
    {
        SF_LOG_INFO("server.loading", ">> Loaded 0 default permission definitions. DB table `rbac_default_permissions` is empty.");
        return;
    }
 
    uint8 secId = 255;
    rbac::RBACPermissionContainer* permissions = NULL;
    do
    {
        Field* field = result->Fetch();
        uint32 newId = field[0].GetUInt32();
        if (secId != newId)
        {
            secId = newId;
            permissions = &_defaultPermissions[secId];
        }
 
        permissions->insert(field[1].GetUInt32());
        ++count3;
    } while (result->NextRow());
 
    SF_LOG_INFO("server.loading", ">> Loaded %u permission definitions, %u linked permissions and %u default permissions in %u ms", count1, count2, count3, GetMSTimeDiffToNow(oldMSTime));
}
 
void AccountMgr::UpdateAccountAccess(rbac::RBACData* rbac, uint32 accountId, uint8 securityLevel, int32 realmId)
{
    if (rbac && securityLevel == rbac->GetSecurityLevel())
        rbac->SetSecurityLevel(securityLevel);
 
    // Delete old security level from DB
    if (realmId == -1)
    {
        PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_ACCOUNT_ACCESS);
        stmt->setUInt32(0, accountId);
        LoginDatabase.Execute(stmt);
    }
    else
    {
        PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_ACCOUNT_ACCESS_BY_REALM);
        stmt->setUInt32(0, accountId);
        stmt->setUInt32(1, realmId);
        LoginDatabase.Execute(stmt);
    }
 
    // Add new security level
    if (securityLevel)
    {
        PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_ACCOUNT_ACCESS);
        stmt->setUInt32(0, accountId);
        stmt->setUInt8(1, securityLevel);
        stmt->setInt32(2, realmId);
        LoginDatabase.Execute(stmt);
    }
}
 
rbac::RBACPermission const* AccountMgr::GetRBACPermission(uint32 permissionId) const
{
    SF_LOG_TRACE("rbac", "AccountMgr::GetRBACPermission: %u", permissionId);
    rbac::RBACPermissionsContainer::const_iterator it = _permissions.find(permissionId);
    if (it != _permissions.end())
        return it->second;
 
    return NULL;
}
 
bool AccountMgr::HasPermission(uint32 accountId, uint32 permissionId, uint32 realmId)
{
    if (!accountId)
    {
        SF_LOG_ERROR("rbac", "AccountMgr::HasPermission: Wrong accountId 0");
        return false;
    }
 
    rbac::RBACData rbac(accountId, "", realmId);
    rbac.LoadFromDB();
    bool hasPermission = rbac.HasPermission(permissionId);
 
    SF_LOG_DEBUG("rbac", "AccountMgr::HasPermission [AccountId: %u, PermissionId: %u, realmId: %d]: %u",
        accountId, permissionId, realmId, hasPermission);
    return hasPermission;
}
 
void AccountMgr::ClearRBAC()
{
    for (rbac::RBACPermissionsContainer::iterator itr = _permissions.begin(); itr != _permissions.end(); ++itr)
        delete itr->second;
 
    _permissions.clear();
    _defaultPermissions.clear();
}
 
rbac::RBACPermissionContainer const& AccountMgr::GetRBACDefaultPermissions(uint8 secLevel)
{
    SF_LOG_TRACE("rbac", "AccountMgr::GetRBACDefaultPermissions: secLevel %u - size: %u", secLevel, uint32(_defaultPermissions[secLevel].size()));
    return _defaultPermissions[secLevel];
}